diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00001.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00001.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b58400ebdf01445041beda0dec84f6380c5a044
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00001.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00001")
+public class BenchmarkTest00001 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00001", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00001.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00001")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + param;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00002.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00002.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e9849f89adb28845fb7be8013fe37a48aa0045c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00002.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00002")
+public class BenchmarkTest00002 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00002", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00002.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00002")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + param;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00003.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00003.java
new file mode 100644
index 0000000000000000000000000000000000000000..13f248f0f022d7633d2474ae881bf4a11ec5d4a4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00003.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00003")
+public class BenchmarkTest00003 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00003", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00003.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00003")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00004.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00004.java
new file mode 100644
index 0000000000000000000000000000000000000000..a841f3f5a7dc381f8341d069f1492d3a97a475d6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00004.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00004")
+public class BenchmarkTest00004 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00004", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00004.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00004")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(param, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(param)
+                                + "' with value: '10340' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00005.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00005.java
new file mode 100644
index 0000000000000000000000000000000000000000..db574c6ac1ed2ed90585a8b95574c24f25eb9f8e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00005.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00005")
+public class BenchmarkTest00005 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00005") != null) {
+            param = request.getHeader("BenchmarkTest00005");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00006.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00006.java
new file mode 100644
index 0000000000000000000000000000000000000000..80c89e60e4a2b100e7a6ce3dea7320163d21f4ff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00006.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00006")
+public class BenchmarkTest00006 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00006") != null) {
+            param = request.getHeader("BenchmarkTest00006");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + param);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00007.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00007.java
new file mode 100644
index 0000000000000000000000000000000000000000..048d64f0ba44309ef6395ad0833288efd53e1ede
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00007.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00007")
+public class BenchmarkTest00007 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00007") != null) {
+            param = request.getHeader("BenchmarkTest00007");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {param};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00008.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00008.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d3e5e23e70a17ee5c9600d7610a32c714d98f68
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00008.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00008")
+public class BenchmarkTest00008 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00008") != null) {
+            param = request.getHeader("BenchmarkTest00008");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String sql = "{call " + param + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00009.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00009.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc1e097e4355a1e2d6015cd03a7ae865b4cd5e6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00009.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00009")
+public class BenchmarkTest00009 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00010.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00010.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a3524874ba3b9e89bf19ce5a3ab0025fade8464
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00010.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00010")
+public class BenchmarkTest00010 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00011.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00011.java
new file mode 100644
index 0000000000000000000000000000000000000000..613457b1d5f4450ef7d7d5cde13656efea7cb272
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00011.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00011")
+public class BenchmarkTest00011 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00011");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        java.io.File fileTarget = new java.io.File(param, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00012.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00012.java
new file mode 100644
index 0000000000000000000000000000000000000000..792daf19c1efc316978da3b4e19fd127167193e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00012.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00012")
+public class BenchmarkTest00012 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00012");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + param + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00013.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00013.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa0b2a460318a4abea9e4291c22eb8c2b93897e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00013.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00013")
+public class BenchmarkTest00013 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, param, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00014.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00014.java
new file mode 100644
index 0000000000000000000000000000000000000000..229eee02b167450ffdec11beb88bb88d3435cf89
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00014.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00014")
+public class BenchmarkTest00014 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(param, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00015.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00015.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8fbac0dba013c7b479865f5f013a0cc27533c0d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00015.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00015")
+public class BenchmarkTest00015 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00015");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + param);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00016.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00016.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd989ce9fc199529a468d3de6455f85bbc3c56ab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00016.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00016")
+public class BenchmarkTest00016 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00016");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00017.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00017.java
new file mode 100644
index 0000000000000000000000000000000000000000..a970a74d29289cf23af898ceebbc2a075582f5ef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00017.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00017")
+public class BenchmarkTest00017 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00017");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + param);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00018.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00018.java
new file mode 100644
index 0000000000000000000000000000000000000000..c54093a7a7fc8e788e1b6748dabdc38f27cc493a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00018.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00018")
+public class BenchmarkTest00018 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00018");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + param + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00019.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00019.java
new file mode 100644
index 0000000000000000000000000000000000000000..53250ad4bac37bf54a7cb952c6f9375e71bfb07a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00019.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00019")
+public class BenchmarkTest00019 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.io.InputStream param = request.getInputStream();
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00020.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00020.java
new file mode 100644
index 0000000000000000000000000000000000000000..72b52f2dbf3effd16070c83bbf3736ebf3b93b6c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00020.java	
@@ -0,0 +1,133 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00020")
+public class BenchmarkTest00020 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00020");
+        if (param == null) param = "";
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00021.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00021.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5669a4fc2474c45daf01b37402a54d335d4c0df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00021.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00021")
+public class BenchmarkTest00021 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00021");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + param + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00022.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00022.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f21eb09d9111bc2e5dfa178c2e4f7dc76790fc0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00022.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00022")
+public class BenchmarkTest00022 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00022");
+        if (param == null) param = "";
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00023.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00023.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e669dd4e1948624a72c80cd19c609f1e6ef26f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00023.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00023")
+public class BenchmarkTest00023 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00023");
+        if (param == null) param = "";
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00024.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00024.java
new file mode 100644
index 0000000000000000000000000000000000000000..8daefab7140dc180f8bc0364a81a7da98d93c9ec
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00024.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00024")
+public class BenchmarkTest00024 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00024");
+        if (param == null) param = "";
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + param + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00025.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00025.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a41fa7e0810da7a479dec7fce88634a431fca30
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00025.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00025")
+public class BenchmarkTest00025 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00025");
+        if (param == null) param = "";
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00026.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00026.java
new file mode 100644
index 0000000000000000000000000000000000000000..4cff3db946f4277734bfe9a43ddfbbe97a458bab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00026.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00026")
+public class BenchmarkTest00026 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00026");
+        if (param == null) param = "";
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00027.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00027.java
new file mode 100644
index 0000000000000000000000000000000000000000..28d2f047b0097da35b018c845ca7386bb8a6df34
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00027.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00027")
+public class BenchmarkTest00027 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00027");
+        if (param == null) param = "";
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + param + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00028.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00028.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9782b848a7cebc361f9d991fbce707867135755
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00028.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00028")
+public class BenchmarkTest00028 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00028");
+            if (values != null) param = values[0];
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + param;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00029.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00029.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7c646048a36d7f316a44941eaf7e8e77bc4137f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00029.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00029")
+public class BenchmarkTest00029 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00029");
+            if (values != null) param = values[0];
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00030.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00030.java
new file mode 100644
index 0000000000000000000000000000000000000000..cbef22aa3e809cc92eed0a1484cc64627593ec23
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00030.java	
@@ -0,0 +1,37 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00030")
+public class BenchmarkTest00030 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00030");
+            if (values != null) param = values[0];
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(param, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00031.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00031.java
new file mode 100644
index 0000000000000000000000000000000000000000..a100495e1bcc27e088b20efb5b5746716eabb3e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00031.java	
@@ -0,0 +1,42 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00031")
+public class BenchmarkTest00031 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00031");
+            if (values != null) param = values[0];
+        }
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", param);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(param)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00032.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00032.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a1ac213f85ab347983fb7c8d3be5626366b2aaa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00032.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00032")
+public class BenchmarkTest00032 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00032");
+            if (values != null) param = values[0];
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00033.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00033.java
new file mode 100644
index 0000000000000000000000000000000000000000..e68f893ee9db79107b556db04e4fc5b84ba28f95
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00033.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00033")
+public class BenchmarkTest00033 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00033");
+            if (values != null) param = values[0];
+        }
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00034.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00034.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f5159a24a811c873c47668889c10e904f127638
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00034.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00034")
+public class BenchmarkTest00034 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00034");
+            if (values != null) param = values[0];
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00035.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00035.java
new file mode 100644
index 0000000000000000000000000000000000000000..af5eb865936845251985eb417bc4b26be09200f8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00035.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00035")
+public class BenchmarkTest00035 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00035")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00036.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00036.java
new file mode 100644
index 0000000000000000000000000000000000000000..82f15728075ce52f20f0ae80b010c68bfed3278f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00036.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00036")
+public class BenchmarkTest00036 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00036")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (param != null) {
+            length = param.length();
+            response.getWriter().write(param.toCharArray(), 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00037.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00037.java
new file mode 100644
index 0000000000000000000000000000000000000000..fbceb1e7d400e2679540a0410fc576ed535c92eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00037.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00037")
+public class BenchmarkTest00037 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00037")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + param + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00038.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00038.java
new file mode 100644
index 0000000000000000000000000000000000000000..13a4a322589af3d22d9259b558d14115ddcddcff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00038.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00038")
+public class BenchmarkTest00038 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00038")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00039.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00039.java
new file mode 100644
index 0000000000000000000000000000000000000000..fff4159d49b6033f77cde3227b211d068721b648
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00039.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00039")
+public class BenchmarkTest00039 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00039")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + param + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00040.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00040.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc80a4bf68ef3dc31df30be027d5a4b5885e1ed7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00040.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00040")
+public class BenchmarkTest00040 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00040");
+        if (param == null) param = "";
+
+        java.io.File fileTarget = new java.io.File(param);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00041.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00041.java
new file mode 100644
index 0000000000000000000000000000000000000000..754542c41fa03a7147da734f7d14895ce029d5f7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00041.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00041")
+public class BenchmarkTest00041 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00041");
+        if (param == null) param = "";
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (param != null) {
+            length = param.length();
+            response.getWriter().write(param, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00042.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00042.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c680602e171869b0a4941a755844650cb5a1507
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00042.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00042")
+public class BenchmarkTest00042 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00042");
+        if (param == null) param = "";
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00043.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00043.java
new file mode 100644
index 0000000000000000000000000000000000000000..5bc876330eade763d49b4aca836a85d97efea977
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00043.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00043")
+public class BenchmarkTest00043 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00043");
+        if (param == null) param = "";
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + param + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00044.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00044.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4e8fcd190f23343d4952e5da27bcddce9a54b10
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00044.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00044")
+public class BenchmarkTest00044 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00044");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + param + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00045.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00045.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd6a494a590f0d3f05da99598131adfad5ed3242
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00045.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00045")
+public class BenchmarkTest00045 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00045");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + param;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR +
+        // param).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00046.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00046.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4550201e289164ebe0999c3fd3620f2137dbd85
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00046.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00046")
+public class BenchmarkTest00046 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00046");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00047.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00047.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4fc684471a4b2732c04d2b58ba2f7e5d19e44f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00047.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00047")
+public class BenchmarkTest00047 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00047" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00047"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00047" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(param, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00048.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00048.java
new file mode 100644
index 0000000000000000000000000000000000000000..f42fcc9ab68a155c5e66cb4d8c13faf4b30673e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00048.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00048")
+public class BenchmarkTest00048 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00048" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00048"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00048" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(param.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00049.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00049.java
new file mode 100644
index 0000000000000000000000000000000000000000..d783465bdd982f7625c31d945fec8d0a37a93544
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00049.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00049")
+public class BenchmarkTest00049 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00049" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00049"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00049" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + param);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00050.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00050.java
new file mode 100644
index 0000000000000000000000000000000000000000..96325acf7be76ea5e14f60b2dedeec02ced49f32
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00050.java	
@@ -0,0 +1,134 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00050")
+public class BenchmarkTest00050 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00050");
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = param;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00051.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00051.java
new file mode 100644
index 0000000000000000000000000000000000000000..4fff20645227de691eb79c0276ffc9d03fd56189
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00051.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00051")
+public class BenchmarkTest00051 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00051");
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + param};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00052.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00052.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b1598c5108f8172fc6bd959cb8d2a924e579cda
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00052.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00052")
+public class BenchmarkTest00052 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        // some code
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00052");
+
+        String sql = "{call " + param + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00053.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00053.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee8cd792ac66fc9acd7d3acd4b34e1cb30ed61c8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00053.java	
@@ -0,0 +1,154 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00053")
+public class BenchmarkTest00053 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00053", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-00/BenchmarkTest00053.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00053")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00054.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00054.java
new file mode 100644
index 0000000000000000000000000000000000000000..bab334ec192195498afc2d3edda083f8280216f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00054.java	
@@ -0,0 +1,150 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00054")
+public class BenchmarkTest00054 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00054", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-00/BenchmarkTest00054.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00054")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00055.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00055.java
new file mode 100644
index 0000000000000000000000000000000000000000..d5d897f86113fd085e43e6cf617e2f33fc270e8a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00055.java	
@@ -0,0 +1,153 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00055")
+public class BenchmarkTest00055 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00055", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-00/BenchmarkTest00055.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00055")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00056.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00056.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9c70e4f1fe79c225eec5aa3d99877ccf6df0c8b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00056.java	
@@ -0,0 +1,163 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00056")
+public class BenchmarkTest00056 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00056", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-00/BenchmarkTest00056.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00056")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00057.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00057.java
new file mode 100644
index 0000000000000000000000000000000000000000..37ea1d556629e643e9cc276728ae4adad5254d60
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00057.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00057")
+public class BenchmarkTest00057 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00057", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-00/BenchmarkTest00057.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00057")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00058.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00058.java
new file mode 100644
index 0000000000000000000000000000000000000000..280b3aea3099b88af17e22aa4b5a9221a4fec352
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00058.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00058")
+public class BenchmarkTest00058 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00058", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-00/BenchmarkTest00058.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00058")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00059.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00059.java
new file mode 100644
index 0000000000000000000000000000000000000000..a85dc591556398fdaad8a82fb10566ce586eb96f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00059.java	
@@ -0,0 +1,121 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00059")
+public class BenchmarkTest00059 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00059", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-00/BenchmarkTest00059.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00059")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        StringBuilder sbxyz22532 = new StringBuilder(param);
+        String bar = sbxyz22532.append("_SafeStuff").toString();
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00060.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00060.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e4bf92f193784b49674921faebeebae88287da0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00060.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00060")
+public class BenchmarkTest00060 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00060", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00060.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00060")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00061.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00061.java
new file mode 100644
index 0000000000000000000000000000000000000000..a14335e7daee0923760947e7ce4d61061b32fbb1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00061.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00061")
+public class BenchmarkTest00061 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00061", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00061.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00061")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00062.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00062.java
new file mode 100644
index 0000000000000000000000000000000000000000..53207e4e782208a18a1eabbd8df41ee8afac0b56
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00062.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00062")
+public class BenchmarkTest00062 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00062", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00062.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00062")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map77232 = new java.util.HashMap<String, Object>();
+        map77232.put("keyA-77232", "a-Value"); // put some stuff in the collection
+        map77232.put("keyB-77232", param); // put it in a collection
+        map77232.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map77232.get("keyB-77232"); // get it back out
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00063.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00063.java
new file mode 100644
index 0000000000000000000000000000000000000000..42b5a217d70edb5a7488b13e7a2f3fb6bfc9a58c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00063.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00063")
+public class BenchmarkTest00063 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00063", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00063.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00063")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00064.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00064.java
new file mode 100644
index 0000000000000000000000000000000000000000..ffefa29f00a445ae0d93dd9dcf4838f868411def
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00064.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00064")
+public class BenchmarkTest00064 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00064", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00064.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00064")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00065.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00065.java
new file mode 100644
index 0000000000000000000000000000000000000000..e497651fab4aff1dc164d3d7acb79f7f7c8433c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00065.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00065")
+public class BenchmarkTest00065 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00065", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-00/BenchmarkTest00065.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00065")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00066.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00066.java
new file mode 100644
index 0000000000000000000000000000000000000000..da8f92cb816b05248424cd9d6025718cb8fb496d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00066.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00066")
+public class BenchmarkTest00066 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00066", "anything");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00066.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00066")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00067.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00067.java
new file mode 100644
index 0000000000000000000000000000000000000000..56dbcf00519d9293a5eba9249810391be1d98137
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00067.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00067")
+public class BenchmarkTest00067 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00067", "anything");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00067.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00067")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a71153 = param; // assign
+        StringBuilder b71153 = new StringBuilder(a71153); // stick in stringbuilder
+        b71153.append(" SafeStuff"); // append some safe content
+        b71153.replace(
+                b71153.length() - "Chars".length(),
+                b71153.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map71153 = new java.util.HashMap<String, Object>();
+        map71153.put("key71153", b71153.toString()); // put in a collection
+        String c71153 = (String) map71153.get("key71153"); // get it back out
+        String d71153 = c71153.substring(0, c71153.length() - 1); // extract most of it
+        String e71153 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d71153.getBytes()))); // B64 encode and decode it
+        String f71153 = e71153.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g71153 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g71153); // reflection
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00068.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00068.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bb80145d1508c99c9df6d0597cef4edeaa3dbb5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00068.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00068")
+public class BenchmarkTest00068 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00068", "anything");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00068.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00068")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00069.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00069.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5203ce5c748a92df2fb605cfa265a72aa4b4b7f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00069.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00069")
+public class BenchmarkTest00069 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00069", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00069.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00069")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00070.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00070.java
new file mode 100644
index 0000000000000000000000000000000000000000..36ed68a4325b7c5325672d5de2921811dd020885
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00070.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00070")
+public class BenchmarkTest00070 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00070", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00070.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00070")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00071.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00071.java
new file mode 100644
index 0000000000000000000000000000000000000000..9489c77a0627bd96ace7bf416ac05e8d9fc34537
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00071.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00071")
+public class BenchmarkTest00071 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00071", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00071.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00071")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00072.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00072.java
new file mode 100644
index 0000000000000000000000000000000000000000..c64b57e688ad269e6cfed250bd32190cb9f907bc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00072.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00072")
+public class BenchmarkTest00072 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00072", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00072.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00072")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00073.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00073.java
new file mode 100644
index 0000000000000000000000000000000000000000..d207d78d97631b6b987f05e5fe9d2d3fa1b16f5a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00073.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00073")
+public class BenchmarkTest00073 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00073", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00073.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00073")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00074.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00074.java
new file mode 100644
index 0000000000000000000000000000000000000000..0eb3226b36ff5c1067ed65606ad17198aab0d978
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00074.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00074")
+public class BenchmarkTest00074 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00074", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00074.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00074")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map98790 = new java.util.HashMap<String, Object>();
+        map98790.put("keyA-98790", "a-Value"); // put some stuff in the collection
+        map98790.put("keyB-98790", param); // put it in a collection
+        map98790.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map98790.get("keyB-98790"); // get it back out
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00075.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00075.java
new file mode 100644
index 0000000000000000000000000000000000000000..29951fc1cd5ef9b1844a5820305e2506f5dc539c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00075.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00075")
+public class BenchmarkTest00075 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00075", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00075.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00075")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00076.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00076.java
new file mode 100644
index 0000000000000000000000000000000000000000..8be4ff3b5cd1c495eb925ab319e588da6471051a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00076.java	
@@ -0,0 +1,121 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00076")
+public class BenchmarkTest00076 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00076", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-00/BenchmarkTest00076.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00076")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00077.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00077.java
new file mode 100644
index 0000000000000000000000000000000000000000..757ccabf18873c4c2d2d0892d8b8ff528c22879a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00077.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00077")
+public class BenchmarkTest00077 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00077", "ECHOOO");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-00/BenchmarkTest00077.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00077")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00078.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00078.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4fb3a4773bcf2c893f5727c565566a212c63d38
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00078.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00078")
+public class BenchmarkTest00078 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00078", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00078.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00078")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00079.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00079.java
new file mode 100644
index 0000000000000000000000000000000000000000..384f1f07efb05d8909f8781ad1e52aca3bb85ce0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00079.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00079")
+public class BenchmarkTest00079 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00079", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00079.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00079")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map18384 = new java.util.HashMap<String, Object>();
+        map18384.put("keyA-18384", "a-Value"); // put some stuff in the collection
+        map18384.put("keyB-18384", param); // put it in a collection
+        map18384.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map18384.get("keyB-18384"); // get it back out
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00080.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00080.java
new file mode 100644
index 0000000000000000000000000000000000000000..52844a8ddb438f8f69cce089d0b7f553266dec44
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00080.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00080")
+public class BenchmarkTest00080 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00080", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00080.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00080")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00081.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00081.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d31f310fe54fcdff48298bc64984a4bffb63720
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00081.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00081")
+public class BenchmarkTest00081 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00081", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00081.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00081")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00082.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00082.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d2ffbb1f3c1cde8f5cfa27557621573241a213b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00082.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00082")
+public class BenchmarkTest00082 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00082", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00082.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00082")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        StringBuilder sbxyz58640 = new StringBuilder(param);
+        String bar = sbxyz58640.append("_SafeStuff").toString();
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00083.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00083.java
new file mode 100644
index 0000000000000000000000000000000000000000..faf3612219dd2150f1a8022a9c2bf9399ab31666
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00083.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00083")
+public class BenchmarkTest00083 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00083", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00083.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00083")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00084.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00084.java
new file mode 100644
index 0000000000000000000000000000000000000000..974d949b731ef48f98eba4eeea029ccc5db817d8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00084.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00084")
+public class BenchmarkTest00084 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00084", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00084.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00084")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00085.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00085.java
new file mode 100644
index 0000000000000000000000000000000000000000..a20ad4661e1234e67aacc0c4bd1efdbbbf184775
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00085.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00085")
+public class BenchmarkTest00085 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00085", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00085.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00085")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map43974 = new java.util.HashMap<String, Object>();
+        map43974.put("keyA-43974", "a-Value"); // put some stuff in the collection
+        map43974.put("keyB-43974", param); // put it in a collection
+        map43974.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map43974.get("keyB-43974"); // get it back out
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00086.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00086.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe3e074a7b038c1756b4b1880cbab7f79dea055a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00086.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00086")
+public class BenchmarkTest00086 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00086", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00086.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00086")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00087.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00087.java
new file mode 100644
index 0000000000000000000000000000000000000000..87912cb4be7011118919828a577cd91a66db9600
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00087.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00087")
+public class BenchmarkTest00087 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00087", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/securecookie-00/BenchmarkTest00087.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00087")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00088.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00088.java
new file mode 100644
index 0000000000000000000000000000000000000000..331aef2a690daac337186acedfbbfbb22fb6ecd0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00088.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00088")
+public class BenchmarkTest00088 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00088", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/securecookie-00/BenchmarkTest00088.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00088")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00089.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00089.java
new file mode 100644
index 0000000000000000000000000000000000000000..e97f84005030daedacd845744f70c7ca90acc8a2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00089.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00089")
+public class BenchmarkTest00089 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00089", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/securecookie-00/BenchmarkTest00089.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00089")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00090.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00090.java
new file mode 100644
index 0000000000000000000000000000000000000000..0156bdf294a2a6f7d8ec3a8fd4500e3fe55d5c24
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00090.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00090")
+public class BenchmarkTest00090 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00090", "ls");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-00/BenchmarkTest00090.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00090")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00091.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00091.java
new file mode 100644
index 0000000000000000000000000000000000000000..58929e4c661019b7192cbd9316c3d712a8bc2396
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00091.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00091")
+public class BenchmarkTest00091 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00091", "FOO%3Decho+Injection");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-00/BenchmarkTest00091.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00091")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = param;
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00092.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00092.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f7ab3d13e5728255156efbf37804cec6be96e47
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00092.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00092")
+public class BenchmarkTest00092 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00092", "FOO%3Decho+Injection");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-00/BenchmarkTest00092.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00092")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00093.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00093.java
new file mode 100644
index 0000000000000000000000000000000000000000..2791d1bd4c18f6c37ee3486afb480fc6d67a4319
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00093.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00093")
+public class BenchmarkTest00093 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00093", "ls");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-00/BenchmarkTest00093.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00093")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00094.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00094.java
new file mode 100644
index 0000000000000000000000000000000000000000..f84e02620544e07886411f742d7ea075e778bab9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00094.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00094")
+public class BenchmarkTest00094 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00094", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00094.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00094")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map52993 = new java.util.HashMap<String, Object>();
+        map52993.put("keyA-52993", "a_Value"); // put some stuff in the collection
+        map52993.put("keyB-52993", param); // put it in a collection
+        map52993.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map52993.get("keyB-52993"); // get it back out
+        bar = (String) map52993.get("keyA-52993"); // get safe value back out
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00095.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00095.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a7921b4815d448e5e96589abfc585b0b1b8f1b7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00095.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00095")
+public class BenchmarkTest00095 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00095", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00095.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00095")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map45268 = new java.util.HashMap<String, Object>();
+        map45268.put("keyA-45268", "a-Value"); // put some stuff in the collection
+        map45268.put("keyB-45268", param); // put it in a collection
+        map45268.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map45268.get("keyB-45268"); // get it back out
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00096.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00096.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f228d33fb82dd303597c710b5780875551c21c8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00096.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00096")
+public class BenchmarkTest00096 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00096", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-00/BenchmarkTest00096.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00096")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00097.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00097.java
new file mode 100644
index 0000000000000000000000000000000000000000..03be16501903a859794b52e28e6fdf86181b4aba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00097.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00097")
+public class BenchmarkTest00097 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00097", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00097.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00097")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00098.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00098.java
new file mode 100644
index 0000000000000000000000000000000000000000..5220e0850eacc90335f5414fd77b7e7698536505
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00098.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00098")
+public class BenchmarkTest00098 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00098", "my_user_id");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00098.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00098")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00099.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00099.java
new file mode 100644
index 0000000000000000000000000000000000000000..82c91a7c0e7414df28b42e0844ff42c5130835e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00099.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00099")
+public class BenchmarkTest00099 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00099", "my_userid");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00099.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00099")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00100.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00100.java
new file mode 100644
index 0000000000000000000000000000000000000000..8df378477b615ab000cf580046cfc0cd1fe5e0ba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00100.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00100")
+public class BenchmarkTest00100 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00100", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00100.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00100")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map72344 = new java.util.HashMap<String, Object>();
+        map72344.put("keyA-72344", "a-Value"); // put some stuff in the collection
+        map72344.put("keyB-72344", param); // put it in a collection
+        map72344.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map72344.get("keyB-72344"); // get it back out
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00101.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00101.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fbcba61fa3fa3cdd41ace334bd8020ab9f986be
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00101.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00101")
+public class BenchmarkTest00101 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00101", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00101.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00101")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00102.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00102.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d1c8b8cb629fe5e2bf84f02f9ae58037420596f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00102.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00102")
+public class BenchmarkTest00102 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00102", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00102.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00102")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00103.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00103.java
new file mode 100644
index 0000000000000000000000000000000000000000..960f479e0b58f9d4f05ca717c12e5698373d6c4e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00103.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00103")
+public class BenchmarkTest00103 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00103", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00103.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00103")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00104.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00104.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a2c016e6aa8d0ef39a133b932ca5eef4bc767b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00104.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00104")
+public class BenchmarkTest00104 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00104", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00104.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00104")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00105.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00105.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f06964bfa09c39e8eb93ca936dfe2fbbe649a49
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00105.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00105")
+public class BenchmarkTest00105 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00105", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00105.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00105")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00106.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00106.java
new file mode 100644
index 0000000000000000000000000000000000000000..97f46bf28ce5767e9a3888844d0f0a5654d295f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00106.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00106")
+public class BenchmarkTest00106 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00106", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00106.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00106")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00107.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00107.java
new file mode 100644
index 0000000000000000000000000000000000000000..a55257059219cc070568e125a25dd79a25dbeca3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00107.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00107")
+public class BenchmarkTest00107 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00107", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00107.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00107")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a18521 = param; // assign
+        StringBuilder b18521 = new StringBuilder(a18521); // stick in stringbuilder
+        b18521.append(" SafeStuff"); // append some safe content
+        b18521.replace(
+                b18521.length() - "Chars".length(),
+                b18521.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map18521 = new java.util.HashMap<String, Object>();
+        map18521.put("key18521", b18521.toString()); // put in a collection
+        String c18521 = (String) map18521.get("key18521"); // get it back out
+        String d18521 = c18521.substring(0, c18521.length() - 1); // extract most of it
+        String e18521 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d18521.getBytes()))); // B64 encode and decode it
+        String f18521 = e18521.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g18521 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g18521); // reflection
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00108.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00108.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ab071011c5f3617a27483acea76c217924c873e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00108.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00108")
+public class BenchmarkTest00108 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00108", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00108.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00108")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00109.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00109.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ca4f0cca32778eafc299ca7631f03ad27d8fad5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00109.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00109")
+public class BenchmarkTest00109 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00109", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00109.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00109")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00110.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00110.java
new file mode 100644
index 0000000000000000000000000000000000000000..43abb0d113982fc8a800e7aa5fbcabe6d3450969
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00110.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00110")
+public class BenchmarkTest00110 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00110", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00110.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00110")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a69840 = param; // assign
+        StringBuilder b69840 = new StringBuilder(a69840); // stick in stringbuilder
+        b69840.append(" SafeStuff"); // append some safe content
+        b69840.replace(
+                b69840.length() - "Chars".length(),
+                b69840.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map69840 = new java.util.HashMap<String, Object>();
+        map69840.put("key69840", b69840.toString()); // put in a collection
+        String c69840 = (String) map69840.get("key69840"); // get it back out
+        String d69840 = c69840.substring(0, c69840.length() - 1); // extract most of it
+        String e69840 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d69840.getBytes()))); // B64 encode and decode it
+        String f69840 = e69840.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g69840 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g69840); // reflection
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00111.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00111.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f613be3317c6507c79a472a9efe9df629ab03e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00111.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00111")
+public class BenchmarkTest00111 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00111", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00111.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00111")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00112.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00112.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc35f6e70616ccf205244e67fb28fc2901071016
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00112.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00112")
+public class BenchmarkTest00112 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00112", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00112.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00112")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00113.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00113.java
new file mode 100644
index 0000000000000000000000000000000000000000..c69ce2975932c91cb8570ba8c96ec6710b248063
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00113.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00113")
+public class BenchmarkTest00113 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00113", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00113.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00113")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map21657 = new java.util.HashMap<String, Object>();
+        map21657.put("keyA-21657", "a_Value"); // put some stuff in the collection
+        map21657.put("keyB-21657", param); // put it in a collection
+        map21657.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map21657.get("keyB-21657"); // get it back out
+        bar = (String) map21657.get("keyA-21657"); // get safe value back out
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00114.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00114.java
new file mode 100644
index 0000000000000000000000000000000000000000..04d27c5ad9c7965161079cc08a91655a412bb3d3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00114.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00114")
+public class BenchmarkTest00114 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00114", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00114.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00114")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00115.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00115.java
new file mode 100644
index 0000000000000000000000000000000000000000..9988bd9022b3597fff721842950db397b40cb434
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00115.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00115")
+public class BenchmarkTest00115 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00115", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-00/BenchmarkTest00115.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00115")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map11928 = new java.util.HashMap<String, Object>();
+        map11928.put("keyA-11928", "a-Value"); // put some stuff in the collection
+        map11928.put("keyB-11928", param); // put it in a collection
+        map11928.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map11928.get("keyB-11928"); // get it back out
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00116.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00116.java
new file mode 100644
index 0000000000000000000000000000000000000000..66496ddeb8d9c96fe1d696337fe4c544ebeaf4fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00116.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00116")
+public class BenchmarkTest00116 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00116", "2222");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/xpathi-00/BenchmarkTest00116.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00116")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map51005 = new java.util.HashMap<String, Object>();
+        map51005.put("keyA-51005", "a_Value"); // put some stuff in the collection
+        map51005.put("keyB-51005", param); // put it in a collection
+        map51005.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map51005.get("keyB-51005"); // get it back out
+        bar = (String) map51005.get("keyA-51005"); // get safe value back out
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00117.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00117.java
new file mode 100644
index 0000000000000000000000000000000000000000..30d823bfcb73b29c196b1447d5798dedf35ae16b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00117.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00117")
+public class BenchmarkTest00117 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00117", "2222");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/xpathi-00/BenchmarkTest00117.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00117")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00118.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00118.java
new file mode 100644
index 0000000000000000000000000000000000000000..d55c79e3705beb9302adbeefaa1a812a60d2d053
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00118.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00118")
+public class BenchmarkTest00118 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00118", "2222");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/xpathi-00/BenchmarkTest00118.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00118")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00119.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00119.java
new file mode 100644
index 0000000000000000000000000000000000000000..b068ae970922fe0e34b784658d5a7d4d67241f16
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00119.java	
@@ -0,0 +1,155 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00119")
+public class BenchmarkTest00119 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00119") != null) {
+            param = request.getHeader("BenchmarkTest00119");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a8142 = param; // assign
+        StringBuilder b8142 = new StringBuilder(a8142); // stick in stringbuilder
+        b8142.append(" SafeStuff"); // append some safe content
+        b8142.replace(
+                b8142.length() - "Chars".length(),
+                b8142.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map8142 = new java.util.HashMap<String, Object>();
+        map8142.put("key8142", b8142.toString()); // put in a collection
+        String c8142 = (String) map8142.get("key8142"); // get it back out
+        String d8142 = c8142.substring(0, c8142.length() - 1); // extract most of it
+        String e8142 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d8142.getBytes()))); // B64 encode and decode it
+        String f8142 = e8142.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f8142); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00120.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00120.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2cd7e27db3b8b2c464024004ec153bbd1395f6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00120.java	
@@ -0,0 +1,139 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00120")
+public class BenchmarkTest00120 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00120") != null) {
+            param = request.getHeader("BenchmarkTest00120");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz43804 = new StringBuilder(param);
+            bar = sbxyz43804.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00121.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00121.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec02fa3554d53d051b4b511f461782fa078f2d0a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00121.java	
@@ -0,0 +1,146 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00121")
+public class BenchmarkTest00121 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00121") != null) {
+            param = request.getHeader("BenchmarkTest00121");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00122.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00122.java
new file mode 100644
index 0000000000000000000000000000000000000000..f960a5fe1100ccd7f7fcc65449f30c441b6a5dbb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00122.java	
@@ -0,0 +1,136 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00122")
+public class BenchmarkTest00122 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00122") != null) {
+            param = request.getHeader("BenchmarkTest00122");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00123.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00123.java
new file mode 100644
index 0000000000000000000000000000000000000000..d735ad2e07a6aabe162ba4af133e75b42dc83ddb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00123.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00123")
+public class BenchmarkTest00123 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00123") != null) {
+            param = request.getHeader("BenchmarkTest00123");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00124.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00124.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8abecc2857dbe8a3c0d50e513c8c59819eae447
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00124.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00124")
+public class BenchmarkTest00124 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00124") != null) {
+            param = request.getHeader("BenchmarkTest00124");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00125.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00125.java
new file mode 100644
index 0000000000000000000000000000000000000000..617447b92d7f52b174db7eb34db4b55b6bcdc674
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00125.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00125")
+public class BenchmarkTest00125 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00125") != null) {
+            param = request.getHeader("BenchmarkTest00125");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00126.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00126.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1b535f1688c77b59aeb99b7c7492773fd19c183
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00126.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00126")
+public class BenchmarkTest00126 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00126") != null) {
+            param = request.getHeader("BenchmarkTest00126");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00127.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00127.java
new file mode 100644
index 0000000000000000000000000000000000000000..81698cc4d93455dddc7ae7eac77f2a1e27b65739
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00127.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00127")
+public class BenchmarkTest00127 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00127") != null) {
+            param = request.getHeader("BenchmarkTest00127");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00128.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00128.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f5114b5f19de045b585ed90b437c377f3fd2137
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00128.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00128")
+public class BenchmarkTest00128 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00128") != null) {
+            param = request.getHeader("BenchmarkTest00128");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00129.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00129.java
new file mode 100644
index 0000000000000000000000000000000000000000..46511fdadbcff77e358db199578ab2f8d3aba131
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00129.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00129")
+public class BenchmarkTest00129 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00129") != null) {
+            param = request.getHeader("BenchmarkTest00129");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00130.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00130.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d7461e8e023f8c6d00f3e2fd9968391c8567996
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00130.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00130")
+public class BenchmarkTest00130 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00130") != null) {
+            param = request.getHeader("BenchmarkTest00130");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00131.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00131.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb4dec593df16a01a75cf727b09808b03fc21ccf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00131.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00131")
+public class BenchmarkTest00131 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00131") != null) {
+            param = request.getHeader("BenchmarkTest00131");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00132.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00132.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d08a703096b5bdc52cd4f3c9e2ff15ceb925cc7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00132.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00132")
+public class BenchmarkTest00132 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00132") != null) {
+            param = request.getHeader("BenchmarkTest00132");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00133.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00133.java
new file mode 100644
index 0000000000000000000000000000000000000000..70f5502de344ee1138b9422e903b405fbd11f345
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00133.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00133")
+public class BenchmarkTest00133 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00133") != null) {
+            param = request.getHeader("BenchmarkTest00133");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00134.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00134.java
new file mode 100644
index 0000000000000000000000000000000000000000..815315c36477d38f21034db8be9d887ee4cd7007
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00134.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00134")
+public class BenchmarkTest00134 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00134") != null) {
+            param = request.getHeader("BenchmarkTest00134");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00135.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00135.java
new file mode 100644
index 0000000000000000000000000000000000000000..23f935cfdbd604ad9dd0510a18249026d8744a70
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00135.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00135")
+public class BenchmarkTest00135 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00135") != null) {
+            param = request.getHeader("BenchmarkTest00135");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00136.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00136.java
new file mode 100644
index 0000000000000000000000000000000000000000..eff7ba4e4c921699d7816452c2939d9f0c9b25ea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00136.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00136")
+public class BenchmarkTest00136 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00136") != null) {
+            param = request.getHeader("BenchmarkTest00136");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00137.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00137.java
new file mode 100644
index 0000000000000000000000000000000000000000..39d5a7744be057c64e416378a943c0837aaa884b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00137.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00137")
+public class BenchmarkTest00137 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00137") != null) {
+            param = request.getHeader("BenchmarkTest00137");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map53289 = new java.util.HashMap<String, Object>();
+        map53289.put("keyA-53289", "a_Value"); // put some stuff in the collection
+        map53289.put("keyB-53289", param); // put it in a collection
+        map53289.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map53289.get("keyB-53289"); // get it back out
+        bar = (String) map53289.get("keyA-53289"); // get safe value back out
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00138.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00138.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d7d81d7ca77ac345153b32be67f9436555887ab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00138.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00138")
+public class BenchmarkTest00138 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00138") != null) {
+            param = request.getHeader("BenchmarkTest00138");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00139.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00139.java
new file mode 100644
index 0000000000000000000000000000000000000000..6cd41ff3f200c5e6248319b36291ac8680ecfcd3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00139.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00139")
+public class BenchmarkTest00139 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00139") != null) {
+            param = request.getHeader("BenchmarkTest00139");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a48394 = param; // assign
+        StringBuilder b48394 = new StringBuilder(a48394); // stick in stringbuilder
+        b48394.append(" SafeStuff"); // append some safe content
+        b48394.replace(
+                b48394.length() - "Chars".length(),
+                b48394.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map48394 = new java.util.HashMap<String, Object>();
+        map48394.put("key48394", b48394.toString()); // put in a collection
+        String c48394 = (String) map48394.get("key48394"); // get it back out
+        String d48394 = c48394.substring(0, c48394.length() - 1); // extract most of it
+        String e48394 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d48394.getBytes()))); // B64 encode and decode it
+        String f48394 = e48394.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g48394 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g48394); // reflection
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00140.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00140.java
new file mode 100644
index 0000000000000000000000000000000000000000..7329644a1924a94eed30e3431dfe181ecc469126
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00140.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00140")
+public class BenchmarkTest00140 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00140") != null) {
+            param = request.getHeader("BenchmarkTest00140");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00141.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00141.java
new file mode 100644
index 0000000000000000000000000000000000000000..a919f47b96baec69074ea33487429ee210bcad12
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00141.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00141")
+public class BenchmarkTest00141 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00141") != null) {
+            param = request.getHeader("BenchmarkTest00141");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00142.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00142.java
new file mode 100644
index 0000000000000000000000000000000000000000..393490116fe9c9c6f78a81303bcb588c24018889
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00142.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00142")
+public class BenchmarkTest00142 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00142") != null) {
+            param = request.getHeader("BenchmarkTest00142");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00143.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00143.java
new file mode 100644
index 0000000000000000000000000000000000000000..077da9435b338ca2beb10fe2a4fa04e974b8555e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00143.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00143")
+public class BenchmarkTest00143 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00143") != null) {
+            param = request.getHeader("BenchmarkTest00143");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00144.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00144.java
new file mode 100644
index 0000000000000000000000000000000000000000..425d798d189f63ce298dc7e252cf0bfdf61853d4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00144.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00144")
+public class BenchmarkTest00144 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00145.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00145.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a596035c5c6c8ad2c3a3b7e5abc877f975e3e0a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00145.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00145")
+public class BenchmarkTest00145 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map17589 = new java.util.HashMap<String, Object>();
+        map17589.put("keyA-17589", "a-Value"); // put some stuff in the collection
+        map17589.put("keyB-17589", param); // put it in a collection
+        map17589.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map17589.get("keyB-17589"); // get it back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00146.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00146.java
new file mode 100644
index 0000000000000000000000000000000000000000..7315583969fb1a7710929efdfa266a55545e166e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00146.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00146")
+public class BenchmarkTest00146 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz67327 = new StringBuilder(param);
+            bar = sbxyz67327.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00147.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00147.java
new file mode 100644
index 0000000000000000000000000000000000000000..19826807b710fa811315f8d5ef8bc658807315be
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00147.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00147")
+public class BenchmarkTest00147 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00148.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00148.java
new file mode 100644
index 0000000000000000000000000000000000000000..91bf62d0ab4fdad88c1860d0ef08011f37c098a2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00148.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00148")
+public class BenchmarkTest00148 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00149.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00149.java
new file mode 100644
index 0000000000000000000000000000000000000000..13456790f943eca7993c97eca1720358444c7ea1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00149.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00149")
+public class BenchmarkTest00149 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        StringBuilder sbxyz19132 = new StringBuilder(param);
+        String bar = sbxyz19132.append("_SafeStuff").toString();
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00150.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00150.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd20305e2721de69b25b07f1cfed79736c3a42eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00150.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00150")
+public class BenchmarkTest00150 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00151.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00151.java
new file mode 100644
index 0000000000000000000000000000000000000000..9998cc0c8265f20514968844165609a662268d10
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00151.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00151")
+public class BenchmarkTest00151 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00152.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00152.java
new file mode 100644
index 0000000000000000000000000000000000000000..de7083bf349e49c859f750d0d4a3dc78b328300f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00152.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00152")
+public class BenchmarkTest00152 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00153.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00153.java
new file mode 100644
index 0000000000000000000000000000000000000000..b29b01c7fbb4bb8315d5377d7680110296bf9d50
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00153.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00153")
+public class BenchmarkTest00153 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map96050 = new java.util.HashMap<String, Object>();
+        map96050.put("keyA-96050", "a-Value"); // put some stuff in the collection
+        map96050.put("keyB-96050", param); // put it in a collection
+        map96050.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map96050.get("keyB-96050"); // get it back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00154.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00154.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f65dd3e66a4bf0502a9b53c84cd8b42de548ffb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00154.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00154")
+public class BenchmarkTest00154 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00155.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00155.java
new file mode 100644
index 0000000000000000000000000000000000000000..4101f40a20fbe5be67d45470192452b3b2baaf1e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00155.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00155")
+public class BenchmarkTest00155 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00156.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00156.java
new file mode 100644
index 0000000000000000000000000000000000000000..401907f1e668b84764842e855559c6fcba1838f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00156.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00156")
+public class BenchmarkTest00156 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00157.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00157.java
new file mode 100644
index 0000000000000000000000000000000000000000..a95f6d73df546cffea6308a1ad5ad5daa7346228
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00157.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00157")
+public class BenchmarkTest00157 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00158.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00158.java
new file mode 100644
index 0000000000000000000000000000000000000000..805071003cd3f3de2b4fc351430cc818cde02a58
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00158.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00158")
+public class BenchmarkTest00158 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00158") != null) {
+            param = request.getHeader("BenchmarkTest00158");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00159.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00159.java
new file mode 100644
index 0000000000000000000000000000000000000000..66c221784fb8c0966a6927038132b78d60ca4067
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00159.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00159")
+public class BenchmarkTest00159 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00159") != null) {
+            param = request.getHeader("BenchmarkTest00159");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00160.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00160.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6718ca283eb7390cf2587f6dd624f580bc4d6a1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00160.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00160")
+public class BenchmarkTest00160 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00160") != null) {
+            param = request.getHeader("BenchmarkTest00160");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00161.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00161.java
new file mode 100644
index 0000000000000000000000000000000000000000..b27dc5a30809703d5ddb8e047a87c65787d24a47
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00161.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00161")
+public class BenchmarkTest00161 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00161") != null) {
+            param = request.getHeader("BenchmarkTest00161");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map91760 = new java.util.HashMap<String, Object>();
+        map91760.put("keyA-91760", "a_Value"); // put some stuff in the collection
+        map91760.put("keyB-91760", param); // put it in a collection
+        map91760.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map91760.get("keyB-91760"); // get it back out
+        bar = (String) map91760.get("keyA-91760"); // get safe value back out
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00162.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00162.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b4a9d2ea10012f0a5022c4c3083c05acf467a20
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00162.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00162")
+public class BenchmarkTest00162 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00162") != null) {
+            param = request.getHeader("BenchmarkTest00162");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00163.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00163.java
new file mode 100644
index 0000000000000000000000000000000000000000..16c36c612964a435b21751459c3c3f6ff445b110
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00163.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00163")
+public class BenchmarkTest00163 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00163") != null) {
+            param = request.getHeader("BenchmarkTest00163");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        StringBuilder sbxyz89305 = new StringBuilder(param);
+        String bar = sbxyz89305.append("_SafeStuff").toString();
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00164.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00164.java
new file mode 100644
index 0000000000000000000000000000000000000000..870abc9de1ccdfd3ff60a56ba943db249472b86c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00164.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00164")
+public class BenchmarkTest00164 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00164") != null) {
+            param = request.getHeader("BenchmarkTest00164");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00165.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00165.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ea26a2706b6577f99d1326611eb12c65c77fc7e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00165.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00165")
+public class BenchmarkTest00165 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00165") != null) {
+            param = request.getHeader("BenchmarkTest00165");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00166.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00166.java
new file mode 100644
index 0000000000000000000000000000000000000000..b47d18a0edad328333beedd1236419eb93f7d2c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00166.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00166")
+public class BenchmarkTest00166 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00166") != null) {
+            param = request.getHeader("BenchmarkTest00166");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00167.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00167.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2e9ddb00ab4da604b8ab829d745d6d2950fabd5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00167.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00167")
+public class BenchmarkTest00167 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00167") != null) {
+            param = request.getHeader("BenchmarkTest00167");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00168.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00168.java
new file mode 100644
index 0000000000000000000000000000000000000000..da7dc9017f75c39b350ed55870295aba4190d327
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00168.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00168")
+public class BenchmarkTest00168 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00168") != null) {
+            param = request.getHeader("BenchmarkTest00168");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00169.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00169.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4f733f09d86e3c12a2f2f7aa6673c9bdda03ecd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00169.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00169")
+public class BenchmarkTest00169 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00169") != null) {
+            param = request.getHeader("BenchmarkTest00169");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00170.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00170.java
new file mode 100644
index 0000000000000000000000000000000000000000..855cb13e5210e659b18dc4e66afd40ff3e0e9a4a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00170.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00170")
+public class BenchmarkTest00170 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00170") != null) {
+            param = request.getHeader("BenchmarkTest00170");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a9823 = param; // assign
+        StringBuilder b9823 = new StringBuilder(a9823); // stick in stringbuilder
+        b9823.append(" SafeStuff"); // append some safe content
+        b9823.replace(
+                b9823.length() - "Chars".length(),
+                b9823.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map9823 = new java.util.HashMap<String, Object>();
+        map9823.put("key9823", b9823.toString()); // put in a collection
+        String c9823 = (String) map9823.get("key9823"); // get it back out
+        String d9823 = c9823.substring(0, c9823.length() - 1); // extract most of it
+        String e9823 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d9823.getBytes()))); // B64 encode and decode it
+        String f9823 = e9823.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g9823 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g9823); // reflection
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00171.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00171.java
new file mode 100644
index 0000000000000000000000000000000000000000..715c3662ab60a33dcb5394a2c3b1faffdec477f8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00171.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00171")
+public class BenchmarkTest00171 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00171") != null) {
+            param = request.getHeader("BenchmarkTest00171");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map40534 = new java.util.HashMap<String, Object>();
+        map40534.put("keyA-40534", "a_Value"); // put some stuff in the collection
+        map40534.put("keyB-40534", param); // put it in a collection
+        map40534.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map40534.get("keyB-40534"); // get it back out
+        bar = (String) map40534.get("keyA-40534"); // get safe value back out
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00172.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00172.java
new file mode 100644
index 0000000000000000000000000000000000000000..def9bbaff86546913ea2ad3752e47f5ad1a5468d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00172.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00172")
+public class BenchmarkTest00172 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00172") != null) {
+            param = request.getHeader("BenchmarkTest00172");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map59408 = new java.util.HashMap<String, Object>();
+        map59408.put("keyA-59408", "a-Value"); // put some stuff in the collection
+        map59408.put("keyB-59408", param); // put it in a collection
+        map59408.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map59408.get("keyB-59408"); // get it back out
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00173.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00173.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4b6d12b161efc58a1d5deea787eb0fcad8f6634
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00173.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00173")
+public class BenchmarkTest00173 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00173") != null) {
+            param = request.getHeader("BenchmarkTest00173");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map68097 = new java.util.HashMap<String, Object>();
+        map68097.put("keyA-68097", "a-Value"); // put some stuff in the collection
+        map68097.put("keyB-68097", param); // put it in a collection
+        map68097.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map68097.get("keyB-68097"); // get it back out
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00174.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00174.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b132d86f1f68cdf148058cd9e7c69b3c27dcb21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00174.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00174")
+public class BenchmarkTest00174 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00174") != null) {
+            param = request.getHeader("BenchmarkTest00174");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00175.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00175.java
new file mode 100644
index 0000000000000000000000000000000000000000..0806dfa14128b3a98709e03a35cf9485855ccf24
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00175.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00175")
+public class BenchmarkTest00175 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00175") != null) {
+            param = request.getHeader("BenchmarkTest00175");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map50591 = new java.util.HashMap<String, Object>();
+        map50591.put("keyA-50591", "a_Value"); // put some stuff in the collection
+        map50591.put("keyB-50591", param); // put it in a collection
+        map50591.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map50591.get("keyB-50591"); // get it back out
+        bar = (String) map50591.get("keyA-50591"); // get safe value back out
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00176.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00176.java
new file mode 100644
index 0000000000000000000000000000000000000000..e92034093f29c5bdaf8a130f4fa75073c624404b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00176.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00176")
+public class BenchmarkTest00176 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00176") != null) {
+            param = request.getHeader("BenchmarkTest00176");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00177.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00177.java
new file mode 100644
index 0000000000000000000000000000000000000000..f80d6e55f59d1d0baf403ccae76daaa9e49effa7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00177.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00177")
+public class BenchmarkTest00177 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00177") != null) {
+            param = request.getHeader("BenchmarkTest00177");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00178.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00178.java
new file mode 100644
index 0000000000000000000000000000000000000000..16f8673cfddfdd0d4ea97e370d8a86ba544b04d3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00178.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00178")
+public class BenchmarkTest00178 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00178") != null) {
+            param = request.getHeader("BenchmarkTest00178");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00179.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00179.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d791400aec685468d47c6872580b481c849dc6c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00179.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00179")
+public class BenchmarkTest00179 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00179") != null) {
+            param = request.getHeader("BenchmarkTest00179");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00180.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00180.java
new file mode 100644
index 0000000000000000000000000000000000000000..0cb26ce3cab4f5a5958f087e12a53294cfcd40e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00180.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00180")
+public class BenchmarkTest00180 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00180") != null) {
+            param = request.getHeader("BenchmarkTest00180");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00181.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00181.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a6f53845e3458a46340212c2a84d435f6c3d73b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00181.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00181")
+public class BenchmarkTest00181 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00181") != null) {
+            param = request.getHeader("BenchmarkTest00181");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00182.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00182.java
new file mode 100644
index 0000000000000000000000000000000000000000..0252126ba7d4893e01e2eddfc85689d839340c1e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00182.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00182")
+public class BenchmarkTest00182 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00182") != null) {
+            param = request.getHeader("BenchmarkTest00182");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a48649 = param; // assign
+        StringBuilder b48649 = new StringBuilder(a48649); // stick in stringbuilder
+        b48649.append(" SafeStuff"); // append some safe content
+        b48649.replace(
+                b48649.length() - "Chars".length(),
+                b48649.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map48649 = new java.util.HashMap<String, Object>();
+        map48649.put("key48649", b48649.toString()); // put in a collection
+        String c48649 = (String) map48649.get("key48649"); // get it back out
+        String d48649 = c48649.substring(0, c48649.length() - 1); // extract most of it
+        String e48649 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d48649.getBytes()))); // B64 encode and decode it
+        String f48649 = e48649.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g48649 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g48649); // reflection
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00183.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00183.java
new file mode 100644
index 0000000000000000000000000000000000000000..358869d16b84c99f4711a880b40663c01a405eab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00183.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00183")
+public class BenchmarkTest00183 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00183") != null) {
+            param = request.getHeader("BenchmarkTest00183");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00184.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00184.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ece598c0b456cd8f4dbfebe0f1f7b323c29a22a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00184.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00184")
+public class BenchmarkTest00184 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00184") != null) {
+            param = request.getHeader("BenchmarkTest00184");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map46743 = new java.util.HashMap<String, Object>();
+        map46743.put("keyA-46743", "a-Value"); // put some stuff in the collection
+        map46743.put("keyB-46743", param); // put it in a collection
+        map46743.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map46743.get("keyB-46743"); // get it back out
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00185.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00185.java
new file mode 100644
index 0000000000000000000000000000000000000000..82ddcdf72ae49931a97aab9361022f243ffc40ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00185.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00185")
+public class BenchmarkTest00185 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00185") != null) {
+            param = request.getHeader("BenchmarkTest00185");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map60659 = new java.util.HashMap<String, Object>();
+        map60659.put("keyA-60659", "a_Value"); // put some stuff in the collection
+        map60659.put("keyB-60659", param); // put it in a collection
+        map60659.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map60659.get("keyB-60659"); // get it back out
+        bar = (String) map60659.get("keyA-60659"); // get safe value back out
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00186.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00186.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef412f2b977a3376d7119cc4fbc607d105bc3f3b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00186.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00186")
+public class BenchmarkTest00186 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00186") != null) {
+            param = request.getHeader("BenchmarkTest00186");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a18509 = param; // assign
+        StringBuilder b18509 = new StringBuilder(a18509); // stick in stringbuilder
+        b18509.append(" SafeStuff"); // append some safe content
+        b18509.replace(
+                b18509.length() - "Chars".length(),
+                b18509.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map18509 = new java.util.HashMap<String, Object>();
+        map18509.put("key18509", b18509.toString()); // put in a collection
+        String c18509 = (String) map18509.get("key18509"); // get it back out
+        String d18509 = c18509.substring(0, c18509.length() - 1); // extract most of it
+        String e18509 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d18509.getBytes()))); // B64 encode and decode it
+        String f18509 = e18509.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g18509 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g18509); // reflection
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00187.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00187.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc1e60ef647feb941ca5f950e12dc3da8b17d4da
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00187.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00187")
+public class BenchmarkTest00187 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00187") != null) {
+            param = request.getHeader("BenchmarkTest00187");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00188.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00188.java
new file mode 100644
index 0000000000000000000000000000000000000000..07918eca43e54080ad3aa2335d0c1b3546f203ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00188.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00188")
+public class BenchmarkTest00188 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00188") != null) {
+            param = request.getHeader("BenchmarkTest00188");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00189.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00189.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d1482398687b6f9aa0dd1fbe9de0e0a5a4e413e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00189.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00189")
+public class BenchmarkTest00189 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00189") != null) {
+            param = request.getHeader("BenchmarkTest00189");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a14330 = param; // assign
+        StringBuilder b14330 = new StringBuilder(a14330); // stick in stringbuilder
+        b14330.append(" SafeStuff"); // append some safe content
+        b14330.replace(
+                b14330.length() - "Chars".length(),
+                b14330.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map14330 = new java.util.HashMap<String, Object>();
+        map14330.put("key14330", b14330.toString()); // put in a collection
+        String c14330 = (String) map14330.get("key14330"); // get it back out
+        String d14330 = c14330.substring(0, c14330.length() - 1); // extract most of it
+        String e14330 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d14330.getBytes()))); // B64 encode and decode it
+        String f14330 = e14330.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g14330 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g14330); // reflection
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00190.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00190.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba0cbe1165d435383a766efcd8ecb6abf6cf9b8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00190.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00190")
+public class BenchmarkTest00190 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00190") != null) {
+            param = request.getHeader("BenchmarkTest00190");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00191.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00191.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb38738318d5a5c274bc3c368a360de13e6ac3bd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00191.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00191")
+public class BenchmarkTest00191 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00191") != null) {
+            param = request.getHeader("BenchmarkTest00191");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00192.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00192.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd77a94d1a19b7278b29a2c13bac26bb57dd3309
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00192.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00192")
+public class BenchmarkTest00192 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00192") != null) {
+            param = request.getHeader("BenchmarkTest00192");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00193.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00193.java
new file mode 100644
index 0000000000000000000000000000000000000000..a83998895af5d71df42be83fe62866de4526d43c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00193.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00193")
+public class BenchmarkTest00193 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00193") != null) {
+            param = request.getHeader("BenchmarkTest00193");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00194.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00194.java
new file mode 100644
index 0000000000000000000000000000000000000000..76c26d2cf868dd9a8124f53ade4ebea6dbe797dc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00194.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00194")
+public class BenchmarkTest00194 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00194") != null) {
+            param = request.getHeader("BenchmarkTest00194");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00195.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00195.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a3804cf7a021280031f3867d6320200b4dfd61e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00195.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00195")
+public class BenchmarkTest00195 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00195") != null) {
+            param = request.getHeader("BenchmarkTest00195");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00196.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00196.java
new file mode 100644
index 0000000000000000000000000000000000000000..570ee0e0a8e3288090b94675ba009b0756964aa0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00196.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00196")
+public class BenchmarkTest00196 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00196") != null) {
+            param = request.getHeader("BenchmarkTest00196");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00197.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00197.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5232dea421371005fc6cce02b627dbd5b387e48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00197.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00197")
+public class BenchmarkTest00197 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00197") != null) {
+            param = request.getHeader("BenchmarkTest00197");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00198.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00198.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad471f756e2e14b397428720564a2a7585c82d58
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00198.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00198")
+public class BenchmarkTest00198 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00198") != null) {
+            param = request.getHeader("BenchmarkTest00198");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00199.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00199.java
new file mode 100644
index 0000000000000000000000000000000000000000..47b0c59111fecadf62b73392c009c8e39c581282
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00199.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00199")
+public class BenchmarkTest00199 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00199") != null) {
+            param = request.getHeader("BenchmarkTest00199");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00200.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00200.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f61e042f434ff92ece6273ce03b68d8f3489d64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00200.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00200")
+public class BenchmarkTest00200 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00200") != null) {
+            param = request.getHeader("BenchmarkTest00200");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00201.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00201.java
new file mode 100644
index 0000000000000000000000000000000000000000..51b81e6498ff15c2032d65c4c5cb9cdd9e1dde10
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00201.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00201")
+public class BenchmarkTest00201 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00201") != null) {
+            param = request.getHeader("BenchmarkTest00201");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a60073 = param; // assign
+        StringBuilder b60073 = new StringBuilder(a60073); // stick in stringbuilder
+        b60073.append(" SafeStuff"); // append some safe content
+        b60073.replace(
+                b60073.length() - "Chars".length(),
+                b60073.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map60073 = new java.util.HashMap<String, Object>();
+        map60073.put("key60073", b60073.toString()); // put in a collection
+        String c60073 = (String) map60073.get("key60073"); // get it back out
+        String d60073 = c60073.substring(0, c60073.length() - 1); // extract most of it
+        String e60073 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d60073.getBytes()))); // B64 encode and decode it
+        String f60073 = e60073.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g60073 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g60073); // reflection
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00202.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00202.java
new file mode 100644
index 0000000000000000000000000000000000000000..65f116ecd2ad81487a4159f2882923b04908e243
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00202.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00202")
+public class BenchmarkTest00202 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00202") != null) {
+            param = request.getHeader("BenchmarkTest00202");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a15497 = param; // assign
+        StringBuilder b15497 = new StringBuilder(a15497); // stick in stringbuilder
+        b15497.append(" SafeStuff"); // append some safe content
+        b15497.replace(
+                b15497.length() - "Chars".length(),
+                b15497.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map15497 = new java.util.HashMap<String, Object>();
+        map15497.put("key15497", b15497.toString()); // put in a collection
+        String c15497 = (String) map15497.get("key15497"); // get it back out
+        String d15497 = c15497.substring(0, c15497.length() - 1); // extract most of it
+        String e15497 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d15497.getBytes()))); // B64 encode and decode it
+        String f15497 = e15497.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g15497 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g15497); // reflection
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00203.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00203.java
new file mode 100644
index 0000000000000000000000000000000000000000..defb15e49b936a035954974fc50d0a5f277137fd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00203.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00203")
+public class BenchmarkTest00203 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00203") != null) {
+            param = request.getHeader("BenchmarkTest00203");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00204.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00204.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c1881429ac3dba78b7d9193469854e0ca2e99bc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00204.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00204")
+public class BenchmarkTest00204 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00204") != null) {
+            param = request.getHeader("BenchmarkTest00204");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00205.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00205.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ddcec7f6a405513e721da25491d3a4b31547c9d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00205.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00205")
+public class BenchmarkTest00205 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00205") != null) {
+            param = request.getHeader("BenchmarkTest00205");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00206.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00206.java
new file mode 100644
index 0000000000000000000000000000000000000000..0fd19bd01b0b96c02ed14bae48da40b2933e25a0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00206.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00206")
+public class BenchmarkTest00206 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00206") != null) {
+            param = request.getHeader("BenchmarkTest00206");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a13396 = param; // assign
+        StringBuilder b13396 = new StringBuilder(a13396); // stick in stringbuilder
+        b13396.append(" SafeStuff"); // append some safe content
+        b13396.replace(
+                b13396.length() - "Chars".length(),
+                b13396.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map13396 = new java.util.HashMap<String, Object>();
+        map13396.put("key13396", b13396.toString()); // put in a collection
+        String c13396 = (String) map13396.get("key13396"); // get it back out
+        String d13396 = c13396.substring(0, c13396.length() - 1); // extract most of it
+        String e13396 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d13396.getBytes()))); // B64 encode and decode it
+        String f13396 = e13396.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g13396 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g13396); // reflection
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00207.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00207.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5b7da3acea30da102bde22e91b7ca80ecf38be9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00207.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00207")
+public class BenchmarkTest00207 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest00207") != null) {
+            param = request.getHeader("BenchmarkTest00207");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00208.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00208.java
new file mode 100644
index 0000000000000000000000000000000000000000..8bf6bd4a601cba799e79a422e3b8056c2a965f74
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00208.java	
@@ -0,0 +1,154 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00208")
+public class BenchmarkTest00208 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00209.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00209.java
new file mode 100644
index 0000000000000000000000000000000000000000..64f2ffa31388d8d22de7939d05c745f12a93c033
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00209.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00209")
+public class BenchmarkTest00209 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        StringBuilder sbxyz43235 = new StringBuilder(param);
+        String bar = sbxyz43235.append("_SafeStuff").toString();
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00210.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00210.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6001ae739a4b8f466e975c21c97e2dadc1777be
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00210.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00210")
+public class BenchmarkTest00210 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00211.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00211.java
new file mode 100644
index 0000000000000000000000000000000000000000..292817243814395c4247e42b49f3147c0a561f92
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00211.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00211")
+public class BenchmarkTest00211 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00212.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00212.java
new file mode 100644
index 0000000000000000000000000000000000000000..b987455304874ce8ce6a59d37694a6e67f680da1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00212.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00212")
+public class BenchmarkTest00212 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00213.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00213.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea2c74d27ab2dbcef3f4963ef67718e7cfd923e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00213.java	
@@ -0,0 +1,126 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00213")
+public class BenchmarkTest00213 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00214.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00214.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2ea3e8554a1096269b8b0461b65a5b9c2cfbcd9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00214.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00214")
+public class BenchmarkTest00214 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00215.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00215.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c6e0d05981673c6aed51cabadf209e3604eda06
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00215.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00215")
+public class BenchmarkTest00215 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = param;
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00216.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00216.java
new file mode 100644
index 0000000000000000000000000000000000000000..3279eb460ca429a7a20570b49e6e73750de56b35
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00216.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00216")
+public class BenchmarkTest00216 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00217.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00217.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb64a2048de5a5d73ca546c6629bc6a9c5150ce0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00217.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00217")
+public class BenchmarkTest00217 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        // Chain a bunch of propagators in sequence
+        String a26348 = param; // assign
+        StringBuilder b26348 = new StringBuilder(a26348); // stick in stringbuilder
+        b26348.append(" SafeStuff"); // append some safe content
+        b26348.replace(
+                b26348.length() - "Chars".length(),
+                b26348.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map26348 = new java.util.HashMap<String, Object>();
+        map26348.put("key26348", b26348.toString()); // put in a collection
+        String c26348 = (String) map26348.get("key26348"); // get it back out
+        String d26348 = c26348.substring(0, c26348.length() - 1); // extract most of it
+        String e26348 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d26348.getBytes()))); // B64 encode and decode it
+        String f26348 = e26348.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g26348 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g26348); // reflection
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00218.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00218.java
new file mode 100644
index 0000000000000000000000000000000000000000..166551d399c8063c413afbfb6dce1f7ec34889e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00218.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00218")
+public class BenchmarkTest00218 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00219.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00219.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad95228bcf438a2e8656fb251b30e37ffd9303d5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00219.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00219")
+public class BenchmarkTest00219 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00220.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00220.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4c585b92a39c334fb65221446eefc09f5915eb9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00220.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00220")
+public class BenchmarkTest00220 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        // Chain a bunch of propagators in sequence
+        String a25969 = param; // assign
+        StringBuilder b25969 = new StringBuilder(a25969); // stick in stringbuilder
+        b25969.append(" SafeStuff"); // append some safe content
+        b25969.replace(
+                b25969.length() - "Chars".length(),
+                b25969.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map25969 = new java.util.HashMap<String, Object>();
+        map25969.put("key25969", b25969.toString()); // put in a collection
+        String c25969 = (String) map25969.get("key25969"); // get it back out
+        String d25969 = c25969.substring(0, c25969.length() - 1); // extract most of it
+        String e25969 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d25969.getBytes()))); // B64 encode and decode it
+        String f25969 = e25969.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g25969 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g25969); // reflection
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00221.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00221.java
new file mode 100644
index 0000000000000000000000000000000000000000..61876cfc33834a10d35fa1ad552bab3dbaa4d282
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00221.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00221")
+public class BenchmarkTest00221 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00222.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00222.java
new file mode 100644
index 0000000000000000000000000000000000000000..0348fb7eeb99729c73b0deb470f4a935624be9d3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00222.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00222")
+public class BenchmarkTest00222 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00223.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00223.java
new file mode 100644
index 0000000000000000000000000000000000000000..287f1774edad69aac6447c4dbbb10b891ec11842
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00223.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00223")
+public class BenchmarkTest00223 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map13848 = new java.util.HashMap<String, Object>();
+        map13848.put("keyA-13848", "a-Value"); // put some stuff in the collection
+        map13848.put("keyB-13848", param); // put it in a collection
+        map13848.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map13848.get("keyB-13848"); // get it back out
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00224.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00224.java
new file mode 100644
index 0000000000000000000000000000000000000000..6decf4feec322a78b52fb2bf92c800647a885415
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00224.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00224")
+public class BenchmarkTest00224 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = param;
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00225.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00225.java
new file mode 100644
index 0000000000000000000000000000000000000000..5febeb7fc4f0452a323e76fc2e8db12491b1e0e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00225.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00225")
+public class BenchmarkTest00225 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00226.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00226.java
new file mode 100644
index 0000000000000000000000000000000000000000..60f1b7541486d20613ac74e9ff2949644c704a62
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00226.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00226")
+public class BenchmarkTest00226 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map56895 = new java.util.HashMap<String, Object>();
+        map56895.put("keyA-56895", "a_Value"); // put some stuff in the collection
+        map56895.put("keyB-56895", param); // put it in a collection
+        map56895.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map56895.get("keyB-56895"); // get it back out
+        bar = (String) map56895.get("keyA-56895"); // get safe value back out
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00227.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00227.java
new file mode 100644
index 0000000000000000000000000000000000000000..178009311a2625e25e4e64312b7d584c8f8e5880
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00227.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00227")
+public class BenchmarkTest00227 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        // Chain a bunch of propagators in sequence
+        String a15913 = param; // assign
+        StringBuilder b15913 = new StringBuilder(a15913); // stick in stringbuilder
+        b15913.append(" SafeStuff"); // append some safe content
+        b15913.replace(
+                b15913.length() - "Chars".length(),
+                b15913.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map15913 = new java.util.HashMap<String, Object>();
+        map15913.put("key15913", b15913.toString()); // put in a collection
+        String c15913 = (String) map15913.get("key15913"); // get it back out
+        String d15913 = c15913.substring(0, c15913.length() - 1); // extract most of it
+        String e15913 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d15913.getBytes()))); // B64 encode and decode it
+        String f15913 = e15913.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g15913 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g15913); // reflection
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00228.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00228.java
new file mode 100644
index 0000000000000000000000000000000000000000..e82da5b977e7d51874fe4828b5348c99a428c0c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00228.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00228")
+public class BenchmarkTest00228 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00229.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00229.java
new file mode 100644
index 0000000000000000000000000000000000000000..84dc9c74bb4b26685b00e3ef78a1acf651ccea12
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00229.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00229")
+public class BenchmarkTest00229 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00230.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00230.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae0a1d60bf172d8a537b41e7f45bd88950c7f22d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00230.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00230")
+public class BenchmarkTest00230 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00231.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00231.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8f7a9bd101154602643e4372b31ffe8767bcd7d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00231.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00231")
+public class BenchmarkTest00231 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map59585 = new java.util.HashMap<String, Object>();
+        map59585.put("keyA-59585", "a-Value"); // put some stuff in the collection
+        map59585.put("keyB-59585", param); // put it in a collection
+        map59585.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map59585.get("keyB-59585"); // get it back out
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00232.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00232.java
new file mode 100644
index 0000000000000000000000000000000000000000..62e619a885b483f5e6e24e89662673f63518fc6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00232.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00232")
+public class BenchmarkTest00232 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map84140 = new java.util.HashMap<String, Object>();
+        map84140.put("keyA-84140", "a_Value"); // put some stuff in the collection
+        map84140.put("keyB-84140", param); // put it in a collection
+        map84140.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map84140.get("keyB-84140"); // get it back out
+        bar = (String) map84140.get("keyA-84140"); // get safe value back out
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00233.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00233.java
new file mode 100644
index 0000000000000000000000000000000000000000..44a6e48ec0c89b7c9d82c8ab2fe2d78fa81c6d89
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00233.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00233")
+public class BenchmarkTest00233 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00234.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00234.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b42f3bb81d2d0a67e0452cbd027468dd5f019dd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00234.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00234")
+public class BenchmarkTest00234 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map35995 = new java.util.HashMap<String, Object>();
+        map35995.put("keyA-35995", "a_Value"); // put some stuff in the collection
+        map35995.put("keyB-35995", param); // put it in a collection
+        map35995.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map35995.get("keyB-35995"); // get it back out
+        bar = (String) map35995.get("keyA-35995"); // get safe value back out
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00235.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00235.java
new file mode 100644
index 0000000000000000000000000000000000000000..25f0f6f5230b3152aae71eaa207205900315c259
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00235.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00235")
+public class BenchmarkTest00235 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00236.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00236.java
new file mode 100644
index 0000000000000000000000000000000000000000..af6b1f95d224f245b961d11d26cda35ea2b82464
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00236.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00236")
+public class BenchmarkTest00236 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00237.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00237.java
new file mode 100644
index 0000000000000000000000000000000000000000..64fc0aaf37abb58faf34d2f5ad2a6a9baea05d90
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00237.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00237")
+public class BenchmarkTest00237 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00238.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00238.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d58662599ff8f014bf3678656ff134aea9c47b7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00238.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00238")
+public class BenchmarkTest00238 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00239.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00239.java
new file mode 100644
index 0000000000000000000000000000000000000000..35123718e1f7600c02bd19fe624afa0da37c7f41
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00239.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00239")
+public class BenchmarkTest00239 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        // Chain a bunch of propagators in sequence
+        String a22450 = param; // assign
+        StringBuilder b22450 = new StringBuilder(a22450); // stick in stringbuilder
+        b22450.append(" SafeStuff"); // append some safe content
+        b22450.replace(
+                b22450.length() - "Chars".length(),
+                b22450.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map22450 = new java.util.HashMap<String, Object>();
+        map22450.put("key22450", b22450.toString()); // put in a collection
+        String c22450 = (String) map22450.get("key22450"); // get it back out
+        String d22450 = c22450.substring(0, c22450.length() - 1); // extract most of it
+        String e22450 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d22450.getBytes()))); // B64 encode and decode it
+        String f22450 = e22450.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f22450); // reflection
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00240.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00240.java
new file mode 100644
index 0000000000000000000000000000000000000000..881e0dce5a9ee34c0130cd09037f1356063dfe8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00240.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00240")
+public class BenchmarkTest00240 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00241.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00241.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b09e5ac71984caf7a90e180762a4094411a8c6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00241.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00241")
+public class BenchmarkTest00241 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00242.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00242.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc2bcc5ae6973edd4d2ba1a7777a48a053c3002c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00242.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00242")
+public class BenchmarkTest00242 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00243.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00243.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c1dcc327fcf86647b2349d793cbde5f15f62c75
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00243.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00243")
+public class BenchmarkTest00243 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map86025 = new java.util.HashMap<String, Object>();
+        map86025.put("keyA-86025", "a-Value"); // put some stuff in the collection
+        map86025.put("keyB-86025", param); // put it in a collection
+        map86025.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map86025.get("keyB-86025"); // get it back out
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00244.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00244.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b817a07677f191be5fc751f78fb9bfbf4bde209
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00244.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00244")
+public class BenchmarkTest00244 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00245.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00245.java
new file mode 100644
index 0000000000000000000000000000000000000000..99d991aa43a7e69740307fdea59beb8964e2e6d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00245.java	
@@ -0,0 +1,128 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00245")
+public class BenchmarkTest00245 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        // Chain a bunch of propagators in sequence
+        String a73565 = param; // assign
+        StringBuilder b73565 = new StringBuilder(a73565); // stick in stringbuilder
+        b73565.append(" SafeStuff"); // append some safe content
+        b73565.replace(
+                b73565.length() - "Chars".length(),
+                b73565.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map73565 = new java.util.HashMap<String, Object>();
+        map73565.put("key73565", b73565.toString()); // put in a collection
+        String c73565 = (String) map73565.get("key73565"); // get it back out
+        String d73565 = c73565.substring(0, c73565.length() - 1); // extract most of it
+        String e73565 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d73565.getBytes()))); // B64 encode and decode it
+        String f73565 = e73565.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g73565 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g73565); // reflection
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00246.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00246.java
new file mode 100644
index 0000000000000000000000000000000000000000..096a40edc86763348b915b0da8b668f4a19d592b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00246.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00246")
+public class BenchmarkTest00246 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00247.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00247.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e87ef9b84ba9b4053773245c6fbee15e9c816b1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00247.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00247")
+public class BenchmarkTest00247 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz47256 = new StringBuilder(param);
+            bar = sbxyz47256.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00248.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00248.java
new file mode 100644
index 0000000000000000000000000000000000000000..786b97895e43ddc5ce8e5b9e34c38d214640ca91
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00248.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00248")
+public class BenchmarkTest00248 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00249.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00249.java
new file mode 100644
index 0000000000000000000000000000000000000000..11edbccd165c235027be2cd769af33ef95331bfa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00249.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00249")
+public class BenchmarkTest00249 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00250.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00250.java
new file mode 100644
index 0000000000000000000000000000000000000000..59a92c6afa5d302373696c5a905f80d3e4e36ec0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00250.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00250")
+public class BenchmarkTest00250 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00251.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00251.java
new file mode 100644
index 0000000000000000000000000000000000000000..42cd8f33933acd436fa6eee447eb743b897a62ad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00251.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00251")
+public class BenchmarkTest00251 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00252.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00252.java
new file mode 100644
index 0000000000000000000000000000000000000000..c72407a612ecf16a798712dbb0110fab0fc5eb4b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00252.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00252")
+public class BenchmarkTest00252 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00253.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00253.java
new file mode 100644
index 0000000000000000000000000000000000000000..34bd3df4a81895c8b99a985ae48c5ac3aeab3138
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00253.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00253")
+public class BenchmarkTest00253 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00254.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00254.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e3432a6f1cebd0038de3d7d3e84e2ac9d7287e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00254.java	
@@ -0,0 +1,144 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00254")
+public class BenchmarkTest00254 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00254");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00255.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00255.java
new file mode 100644
index 0000000000000000000000000000000000000000..59b70fbb7e0581d97352b2a2e48ab81480bb406f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00255.java	
@@ -0,0 +1,141 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00255")
+public class BenchmarkTest00255 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00255");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00256.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00256.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b6e49d2d59e8f087c69b02abd21fcf03056b543
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00256.java	
@@ -0,0 +1,151 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00256")
+public class BenchmarkTest00256 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00256");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00257.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00257.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d3dd1a4398fa80c4212eb57eef3b2cb2ac7febb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00257.java	
@@ -0,0 +1,142 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00257")
+public class BenchmarkTest00257 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00257");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        StringBuilder sbxyz60568 = new StringBuilder(param);
+        String bar = sbxyz60568.append("_SafeStuff").toString();
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00258.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00258.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec9ddd58a8fabdf6b97b3d7a45b284beffa73c61
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00258.java	
@@ -0,0 +1,141 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00258")
+public class BenchmarkTest00258 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00258");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00259.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00259.java
new file mode 100644
index 0000000000000000000000000000000000000000..80f194d73d883e9f05bb0d194fea1d7b1b6bdcc7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00259.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00259")
+public class BenchmarkTest00259 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00259");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00260.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00260.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ada6bb680dc46925288034923cc481e7621ae3c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00260.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00260")
+public class BenchmarkTest00260 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00260");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00261.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00261.java
new file mode 100644
index 0000000000000000000000000000000000000000..2555e002d404ce6cb15c643d8ce42e9e8823105f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00261.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00261")
+public class BenchmarkTest00261 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00261");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a3000 = param; // assign
+        StringBuilder b3000 = new StringBuilder(a3000); // stick in stringbuilder
+        b3000.append(" SafeStuff"); // append some safe content
+        b3000.replace(
+                b3000.length() - "Chars".length(),
+                b3000.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map3000 = new java.util.HashMap<String, Object>();
+        map3000.put("key3000", b3000.toString()); // put in a collection
+        String c3000 = (String) map3000.get("key3000"); // get it back out
+        String d3000 = c3000.substring(0, c3000.length() - 1); // extract most of it
+        String e3000 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d3000.getBytes()))); // B64 encode and decode it
+        String f3000 = e3000.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g3000 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g3000); // reflection
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00262.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00262.java
new file mode 100644
index 0000000000000000000000000000000000000000..be1517e3f32cddbd4f8ec5dd8c4a82cc862a699c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00262.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00262")
+public class BenchmarkTest00262 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00262");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00263.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00263.java
new file mode 100644
index 0000000000000000000000000000000000000000..3405f80825f61772ba2381a3e4566d9c50fd8128
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00263.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00263")
+public class BenchmarkTest00263 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00263");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00264.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00264.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f9b8fcdf725f630c835c0dba74a6dac1a3be141
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00264.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00264")
+public class BenchmarkTest00264 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00264");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00265.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00265.java
new file mode 100644
index 0000000000000000000000000000000000000000..a4544e680f96ea98506b35cf1dff094690875028
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00265.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00265")
+public class BenchmarkTest00265 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00265");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00266.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00266.java
new file mode 100644
index 0000000000000000000000000000000000000000..258a760ba2fedf174150224a6d74c0757c6ca15e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00266.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00266")
+public class BenchmarkTest00266 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00266");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map42712 = new java.util.HashMap<String, Object>();
+        map42712.put("keyA-42712", "a-Value"); // put some stuff in the collection
+        map42712.put("keyB-42712", param); // put it in a collection
+        map42712.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map42712.get("keyB-42712"); // get it back out
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00267.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00267.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf23c0852973b00a5c7f76b5b2383e82b3597d6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00267.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00267")
+public class BenchmarkTest00267 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00267");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        StringBuilder sbxyz11795 = new StringBuilder(param);
+        String bar = sbxyz11795.append("_SafeStuff").toString();
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00268.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00268.java
new file mode 100644
index 0000000000000000000000000000000000000000..81eac0ff5ab41e3b96e16bd3370e124928400397
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00268.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00268")
+public class BenchmarkTest00268 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00268");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00269.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00269.java
new file mode 100644
index 0000000000000000000000000000000000000000..b57cdf1cb709aeb31b28b6295a49383bb8808f36
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00269.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00269")
+public class BenchmarkTest00269 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00269");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00270.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00270.java
new file mode 100644
index 0000000000000000000000000000000000000000..6223117e412d695efcd8cf0d5321697c36f44e78
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00270.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00270")
+public class BenchmarkTest00270 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00270");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00271.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00271.java
new file mode 100644
index 0000000000000000000000000000000000000000..484f518be45bec7c4cb381cbfa8eaa8937aeaec0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00271.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00271")
+public class BenchmarkTest00271 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00271");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a75009 = param; // assign
+        StringBuilder b75009 = new StringBuilder(a75009); // stick in stringbuilder
+        b75009.append(" SafeStuff"); // append some safe content
+        b75009.replace(
+                b75009.length() - "Chars".length(),
+                b75009.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map75009 = new java.util.HashMap<String, Object>();
+        map75009.put("key75009", b75009.toString()); // put in a collection
+        String c75009 = (String) map75009.get("key75009"); // get it back out
+        String d75009 = c75009.substring(0, c75009.length() - 1); // extract most of it
+        String e75009 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d75009.getBytes()))); // B64 encode and decode it
+        String f75009 = e75009.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f75009); // reflection
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00272.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00272.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b5e95c2fb39d6fdb739b3764cd040757d69e21b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00272.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00272")
+public class BenchmarkTest00272 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00272");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00273.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00273.java
new file mode 100644
index 0000000000000000000000000000000000000000..58649d33bf2ed6aedcd64792c13d8d55b880ea4c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00273.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00273")
+public class BenchmarkTest00273 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00273");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00274.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00274.java
new file mode 100644
index 0000000000000000000000000000000000000000..cab96fa1ed149d281a7844317059e75b0aed42ad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00274.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00274")
+public class BenchmarkTest00274 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00274");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00275.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00275.java
new file mode 100644
index 0000000000000000000000000000000000000000..9667ea84301490e1fc2bd02e6cea9fe06dca75ac
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00275.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00275")
+public class BenchmarkTest00275 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a28150 = param; // assign
+        StringBuilder b28150 = new StringBuilder(a28150); // stick in stringbuilder
+        b28150.append(" SafeStuff"); // append some safe content
+        b28150.replace(
+                b28150.length() - "Chars".length(),
+                b28150.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map28150 = new java.util.HashMap<String, Object>();
+        map28150.put("key28150", b28150.toString()); // put in a collection
+        String c28150 = (String) map28150.get("key28150"); // get it back out
+        String d28150 = c28150.substring(0, c28150.length() - 1); // extract most of it
+        String e28150 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d28150.getBytes()))); // B64 encode and decode it
+        String f28150 = e28150.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g28150 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g28150); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00276.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00276.java
new file mode 100644
index 0000000000000000000000000000000000000000..5699db27998b04fe889fa7ac5fbe01491381315d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00276.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00276")
+public class BenchmarkTest00276 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00277.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00277.java
new file mode 100644
index 0000000000000000000000000000000000000000..458192670403062db13b8f91e5396bf8fd446cca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00277.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00277")
+public class BenchmarkTest00277 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a54571 = param; // assign
+        StringBuilder b54571 = new StringBuilder(a54571); // stick in stringbuilder
+        b54571.append(" SafeStuff"); // append some safe content
+        b54571.replace(
+                b54571.length() - "Chars".length(),
+                b54571.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map54571 = new java.util.HashMap<String, Object>();
+        map54571.put("key54571", b54571.toString()); // put in a collection
+        String c54571 = (String) map54571.get("key54571"); // get it back out
+        String d54571 = c54571.substring(0, c54571.length() - 1); // extract most of it
+        String e54571 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d54571.getBytes()))); // B64 encode and decode it
+        String f54571 = e54571.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g54571 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g54571); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00278.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00278.java
new file mode 100644
index 0000000000000000000000000000000000000000..aafbf959c1a4dd309cdf2f7b824a58a069750a13
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00278.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00278")
+public class BenchmarkTest00278 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00279.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00279.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a23d50a39d8bb411516219c61b17a344cba3c09
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00279.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00279")
+public class BenchmarkTest00279 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00280.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00280.java
new file mode 100644
index 0000000000000000000000000000000000000000..f73da153520c5a3e563b784be4874dc07efd9530
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00280.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00280")
+public class BenchmarkTest00280 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00281.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00281.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6ab84f436581bfa279ac39e5ab715fc12473a17
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00281.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00281")
+public class BenchmarkTest00281 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00282.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00282.java
new file mode 100644
index 0000000000000000000000000000000000000000..939c7efec67381b948df4f42faa033e71128989c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00282.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00282")
+public class BenchmarkTest00282 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00283.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00283.java
new file mode 100644
index 0000000000000000000000000000000000000000..664e0fee46199cb9ee7abf23fa173e6bfda10b01
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00283.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00283")
+public class BenchmarkTest00283 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00284.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00284.java
new file mode 100644
index 0000000000000000000000000000000000000000..54c5e8232555bf17b8759584fde928be3afb8cb1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00284.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00284")
+public class BenchmarkTest00284 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00285.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00285.java
new file mode 100644
index 0000000000000000000000000000000000000000..baa352049f63e397ff8a196ba3e46707de21a861
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00285.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00285")
+public class BenchmarkTest00285 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00286.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00286.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4c3460fcebaa9e9bbfcd3aa8908048114e5d734
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00286.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00286")
+public class BenchmarkTest00286 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00287.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00287.java
new file mode 100644
index 0000000000000000000000000000000000000000..62bbe940c99f17bbc39afc509a67e6644dbc5607
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00287.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00287")
+public class BenchmarkTest00287 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00288.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00288.java
new file mode 100644
index 0000000000000000000000000000000000000000..793fee0c06b58bfe372516489fe937e05831f05f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00288.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00288")
+public class BenchmarkTest00288 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map34285 = new java.util.HashMap<String, Object>();
+        map34285.put("keyA-34285", "a_Value"); // put some stuff in the collection
+        map34285.put("keyB-34285", param); // put it in a collection
+        map34285.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map34285.get("keyB-34285"); // get it back out
+        bar = (String) map34285.get("keyA-34285"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00289.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00289.java
new file mode 100644
index 0000000000000000000000000000000000000000..d406cbf88588233cd70db5331ff247a47c052d65
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00289.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00289")
+public class BenchmarkTest00289 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00290.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00290.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e6ddbe95a85f0ded725aa7d1e5fd0d05d08b51c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00290.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00290")
+public class BenchmarkTest00290 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        StringBuilder sbxyz73567 = new StringBuilder(param);
+        String bar = sbxyz73567.append("_SafeStuff").toString();
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00291.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00291.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b7ae6ccbe71e813018ab4e99aae1d9c13b25242
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00291.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00291")
+public class BenchmarkTest00291 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00292.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00292.java
new file mode 100644
index 0000000000000000000000000000000000000000..1be74193380956f9f30e578f10dfc29e3290f25f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00292.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00292")
+public class BenchmarkTest00292 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00293.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00293.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f679164fd639750338292212d6584cb157e2f3a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00293.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00293")
+public class BenchmarkTest00293 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00293");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00294.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00294.java
new file mode 100644
index 0000000000000000000000000000000000000000..748f9b203f7fa4c182e4dc6296314deaffbd71ca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00294.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00294")
+public class BenchmarkTest00294 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00294");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00295.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00295.java
new file mode 100644
index 0000000000000000000000000000000000000000..40bc95485cfcf4aa44ab1d9c0dec0cd73a79bb99
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00295.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00295")
+public class BenchmarkTest00295 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00295");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00296.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00296.java
new file mode 100644
index 0000000000000000000000000000000000000000..1df97efbdc83515d105db39cd6f59037158abe34
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00296.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00296")
+public class BenchmarkTest00296 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00296");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00297.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00297.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2e5ac0858edd71783a77326d03ea13a7ebb795a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00297.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00297")
+public class BenchmarkTest00297 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00297");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00298.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00298.java
new file mode 100644
index 0000000000000000000000000000000000000000..67790b9755ab527ed8406d4965f3a04ee9158ec0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00298.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00298")
+public class BenchmarkTest00298 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00298");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00299.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00299.java
new file mode 100644
index 0000000000000000000000000000000000000000..8232d483a5f9175066a888eabc7973342eabc67a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00299.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00299")
+public class BenchmarkTest00299 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00299");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00300.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00300.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d24b9ed3d13b49f6614f934d0015372a563c8d9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00300.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00300")
+public class BenchmarkTest00300 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00300");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00301.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00301.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c5ab4931144ddc95b1cd2f90a2ffc763346c5bd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00301.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00301")
+public class BenchmarkTest00301 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map16074 = new java.util.HashMap<String, Object>();
+        map16074.put("keyA-16074", "a-Value"); // put some stuff in the collection
+        map16074.put("keyB-16074", param); // put it in a collection
+        map16074.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map16074.get("keyB-16074"); // get it back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00302.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00302.java
new file mode 100644
index 0000000000000000000000000000000000000000..9dadc4654547557ce6f2493683fbe0d07380ac19
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00302.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00302")
+public class BenchmarkTest00302 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00302");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00303.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00303.java
new file mode 100644
index 0000000000000000000000000000000000000000..04bed600998637c6a0a24cf7d3bfb72eaf5b824a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00303.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00303")
+public class BenchmarkTest00303 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00303");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00304.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00304.java
new file mode 100644
index 0000000000000000000000000000000000000000..43c70c5970426eaa3dfce2b4c947dfa1f8e0d05b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00304.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00304")
+public class BenchmarkTest00304 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00304");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00305.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00305.java
new file mode 100644
index 0000000000000000000000000000000000000000..9eb7a387421efcf78703fd5f3c31608508a3d3ef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00305.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00305")
+public class BenchmarkTest00305 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00305");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a99928 = param; // assign
+        StringBuilder b99928 = new StringBuilder(a99928); // stick in stringbuilder
+        b99928.append(" SafeStuff"); // append some safe content
+        b99928.replace(
+                b99928.length() - "Chars".length(),
+                b99928.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map99928 = new java.util.HashMap<String, Object>();
+        map99928.put("key99928", b99928.toString()); // put in a collection
+        String c99928 = (String) map99928.get("key99928"); // get it back out
+        String d99928 = c99928.substring(0, c99928.length() - 1); // extract most of it
+        String e99928 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d99928.getBytes()))); // B64 encode and decode it
+        String f99928 = e99928.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g99928 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g99928); // reflection
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00306.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00306.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb38cfd5000f93f4baa7783ae0ca387ba7787130
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00306.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00306")
+public class BenchmarkTest00306 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00306");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00307.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00307.java
new file mode 100644
index 0000000000000000000000000000000000000000..18a6f05b189e134e90dc0522dc5643d108bc8d8a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00307.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00307")
+public class BenchmarkTest00307 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00307");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00308.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00308.java
new file mode 100644
index 0000000000000000000000000000000000000000..f10c46bd1820d627742bfdc7fcf111af157616f5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00308.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00308")
+public class BenchmarkTest00308 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00308");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00309.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00309.java
new file mode 100644
index 0000000000000000000000000000000000000000..5869543ebd967e239861d06fff0ef243ba4145ef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00309.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00309")
+public class BenchmarkTest00309 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00309");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map92785 = new java.util.HashMap<String, Object>();
+        map92785.put("keyA-92785", "a_Value"); // put some stuff in the collection
+        map92785.put("keyB-92785", param); // put it in a collection
+        map92785.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map92785.get("keyB-92785"); // get it back out
+        bar = (String) map92785.get("keyA-92785"); // get safe value back out
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00310.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00310.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c5f183802c7287313b0a50f4ffddb37b8925ade
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00310.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00310")
+public class BenchmarkTest00310 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00310");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00311.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00311.java
new file mode 100644
index 0000000000000000000000000000000000000000..6149cb5b344c34be2b6cec1a129afde2f56e4a0c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00311.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00311")
+public class BenchmarkTest00311 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00311");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00312.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00312.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3dfe65091dbdbc2cf1822d0554ab46aac669435
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00312.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00312")
+public class BenchmarkTest00312 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00312");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00313.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00313.java
new file mode 100644
index 0000000000000000000000000000000000000000..38c9d122f1097f47ac1e5cee7273a660a3850d31
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00313.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00313")
+public class BenchmarkTest00313 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00313");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00314.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00314.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5edb313a26f1b42ca5b8328e2e490282c8320e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00314.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00314")
+public class BenchmarkTest00314 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00314");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00315.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00315.java
new file mode 100644
index 0000000000000000000000000000000000000000..8356c3449b42260d02ad74fc1fbbbe99950791f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00315.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00315")
+public class BenchmarkTest00315 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00315");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map38775 = new java.util.HashMap<String, Object>();
+        map38775.put("keyA-38775", "a_Value"); // put some stuff in the collection
+        map38775.put("keyB-38775", param); // put it in a collection
+        map38775.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map38775.get("keyB-38775"); // get it back out
+        bar = (String) map38775.get("keyA-38775"); // get safe value back out
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00316.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00316.java
new file mode 100644
index 0000000000000000000000000000000000000000..71c79a613121a60329a2e7943be798833ea87596
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00316.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00316")
+public class BenchmarkTest00316 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00316");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a78780 = param; // assign
+        StringBuilder b78780 = new StringBuilder(a78780); // stick in stringbuilder
+        b78780.append(" SafeStuff"); // append some safe content
+        b78780.replace(
+                b78780.length() - "Chars".length(),
+                b78780.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map78780 = new java.util.HashMap<String, Object>();
+        map78780.put("key78780", b78780.toString()); // put in a collection
+        String c78780 = (String) map78780.get("key78780"); // get it back out
+        String d78780 = c78780.substring(0, c78780.length() - 1); // extract most of it
+        String e78780 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d78780.getBytes()))); // B64 encode and decode it
+        String f78780 = e78780.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f78780); // reflection
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00317.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00317.java
new file mode 100644
index 0000000000000000000000000000000000000000..55df8b01d55484a290ad831dfe073c4b558af02b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00317.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00317")
+public class BenchmarkTest00317 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00317");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00318.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00318.java
new file mode 100644
index 0000000000000000000000000000000000000000..515358e1dd929eceb83d51d96e8cd0dc64da710e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00318.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00318")
+public class BenchmarkTest00318 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00318");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a30925 = param; // assign
+        StringBuilder b30925 = new StringBuilder(a30925); // stick in stringbuilder
+        b30925.append(" SafeStuff"); // append some safe content
+        b30925.replace(
+                b30925.length() - "Chars".length(),
+                b30925.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map30925 = new java.util.HashMap<String, Object>();
+        map30925.put("key30925", b30925.toString()); // put in a collection
+        String c30925 = (String) map30925.get("key30925"); // get it back out
+        String d30925 = c30925.substring(0, c30925.length() - 1); // extract most of it
+        String e30925 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d30925.getBytes()))); // B64 encode and decode it
+        String f30925 = e30925.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g30925 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g30925); // reflection
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00319.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00319.java
new file mode 100644
index 0000000000000000000000000000000000000000..6885b92f573fb2ae67d6bf9d2000acc60faf8b38
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00319.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00319")
+public class BenchmarkTest00319 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00319");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00320.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00320.java
new file mode 100644
index 0000000000000000000000000000000000000000..25fc67798c58c7e1cbcc513c67a318d698f00296
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00320.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00320")
+public class BenchmarkTest00320 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00320");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00321.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00321.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d00cef4c400ac4a8dee14fb354ce2c6b9cc8ec2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00321.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00321")
+public class BenchmarkTest00321 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00321");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00322.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00322.java
new file mode 100644
index 0000000000000000000000000000000000000000..c49929875eb6441754ac6d660ae46db4a6f15d1d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00322.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00322")
+public class BenchmarkTest00322 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00322");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map53101 = new java.util.HashMap<String, Object>();
+        map53101.put("keyA-53101", "a_Value"); // put some stuff in the collection
+        map53101.put("keyB-53101", param); // put it in a collection
+        map53101.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map53101.get("keyB-53101"); // get it back out
+        bar = (String) map53101.get("keyA-53101"); // get safe value back out
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00323.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00323.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a2012ad3b828d52afefe925fa5045f625d5956d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00323.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00323")
+public class BenchmarkTest00323 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00323");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00324.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00324.java
new file mode 100644
index 0000000000000000000000000000000000000000..769410699c264128672c0ccd22e56fcaf464d76c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00324.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00324")
+public class BenchmarkTest00324 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00324");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00325.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00325.java
new file mode 100644
index 0000000000000000000000000000000000000000..65d751541d56d1b261bd16eb0a343c5b87e4bd92
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00325.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00325")
+public class BenchmarkTest00325 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00325");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00326.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00326.java
new file mode 100644
index 0000000000000000000000000000000000000000..f190ecc6996f53899a066ccc6e5e1ba9a246208a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00326.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00326")
+public class BenchmarkTest00326 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00326");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00327.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00327.java
new file mode 100644
index 0000000000000000000000000000000000000000..4aa912d691be4191a79c93e7b28ad6e3db1c9040
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00327.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00327")
+public class BenchmarkTest00327 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00327");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00328.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00328.java
new file mode 100644
index 0000000000000000000000000000000000000000..a25de66ed4dff04462dcd9f2141262f3b1f78de2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00328.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00328")
+public class BenchmarkTest00328 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00328");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00329.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00329.java
new file mode 100644
index 0000000000000000000000000000000000000000..1b0546bcf08207a56a0f815e92d0e1c748b965a3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00329.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00329")
+public class BenchmarkTest00329 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00329");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00330.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00330.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a45f25872dcda15af8f3e138d0eb02b490035bc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00330.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00330")
+public class BenchmarkTest00330 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00330");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a55109 = param; // assign
+        StringBuilder b55109 = new StringBuilder(a55109); // stick in stringbuilder
+        b55109.append(" SafeStuff"); // append some safe content
+        b55109.replace(
+                b55109.length() - "Chars".length(),
+                b55109.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map55109 = new java.util.HashMap<String, Object>();
+        map55109.put("key55109", b55109.toString()); // put in a collection
+        String c55109 = (String) map55109.get("key55109"); // get it back out
+        String d55109 = c55109.substring(0, c55109.length() - 1); // extract most of it
+        String e55109 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d55109.getBytes()))); // B64 encode and decode it
+        String f55109 = e55109.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g55109 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g55109); // reflection
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00331.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00331.java
new file mode 100644
index 0000000000000000000000000000000000000000..70142d450435e920a3b38f6e91eef40e902d584e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00331.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00331")
+public class BenchmarkTest00331 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00331");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map59781 = new java.util.HashMap<String, Object>();
+        map59781.put("keyA-59781", "a_Value"); // put some stuff in the collection
+        map59781.put("keyB-59781", param); // put it in a collection
+        map59781.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map59781.get("keyB-59781"); // get it back out
+        bar = (String) map59781.get("keyA-59781"); // get safe value back out
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00332.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00332.java
new file mode 100644
index 0000000000000000000000000000000000000000..21d24cbce89c5da6513130b2d9e517c5d39bec76
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00332.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00332")
+public class BenchmarkTest00332 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00332");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a40477 = param; // assign
+        StringBuilder b40477 = new StringBuilder(a40477); // stick in stringbuilder
+        b40477.append(" SafeStuff"); // append some safe content
+        b40477.replace(
+                b40477.length() - "Chars".length(),
+                b40477.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map40477 = new java.util.HashMap<String, Object>();
+        map40477.put("key40477", b40477.toString()); // put in a collection
+        String c40477 = (String) map40477.get("key40477"); // get it back out
+        String d40477 = c40477.substring(0, c40477.length() - 1); // extract most of it
+        String e40477 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d40477.getBytes()))); // B64 encode and decode it
+        String f40477 = e40477.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g40477 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g40477); // reflection
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00333.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00333.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ada9ed22472c2f86516c890f5d71a980c812fa2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00333.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00333")
+public class BenchmarkTest00333 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00333");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00334.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00334.java
new file mode 100644
index 0000000000000000000000000000000000000000..8929c963723246ba7b7a0f584b06f7f53ee63d53
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00334.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00334")
+public class BenchmarkTest00334 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00334");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a30608 = param; // assign
+        StringBuilder b30608 = new StringBuilder(a30608); // stick in stringbuilder
+        b30608.append(" SafeStuff"); // append some safe content
+        b30608.replace(
+                b30608.length() - "Chars".length(),
+                b30608.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map30608 = new java.util.HashMap<String, Object>();
+        map30608.put("key30608", b30608.toString()); // put in a collection
+        String c30608 = (String) map30608.get("key30608"); // get it back out
+        String d30608 = c30608.substring(0, c30608.length() - 1); // extract most of it
+        String e30608 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d30608.getBytes()))); // B64 encode and decode it
+        String f30608 = e30608.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g30608 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g30608); // reflection
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00335.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00335.java
new file mode 100644
index 0000000000000000000000000000000000000000..27ea64abac3ab1aa834aba35d4df7b75acaa20cb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00335.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00335")
+public class BenchmarkTest00335 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00335");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00336.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00336.java
new file mode 100644
index 0000000000000000000000000000000000000000..b61e9b56cfbc21a9a17fc604f78858f04a003116
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00336.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00336")
+public class BenchmarkTest00336 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00336");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00337.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00337.java
new file mode 100644
index 0000000000000000000000000000000000000000..95037135c3f79f4d19438c4a848ac02c1a72a093
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00337.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00337")
+public class BenchmarkTest00337 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00337");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00338.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00338.java
new file mode 100644
index 0000000000000000000000000000000000000000..9278472c3fdc75302ac2189dfda3e4c7f329c05f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00338.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00338")
+public class BenchmarkTest00338 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00338");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00339.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00339.java
new file mode 100644
index 0000000000000000000000000000000000000000..424f73cb31ee72c660e7f29c0690003a1c553b7b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00339.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00339")
+public class BenchmarkTest00339 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00339");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00340.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00340.java
new file mode 100644
index 0000000000000000000000000000000000000000..59f3ae04f6354528d5dc38ef0eea339825d0ed19
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00340.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00340")
+public class BenchmarkTest00340 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00340");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00341.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00341.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b92152308d112194f740f4ab40e8a725fe0d672
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00341.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00341")
+public class BenchmarkTest00341 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00341");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00342.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00342.java
new file mode 100644
index 0000000000000000000000000000000000000000..d005bc223c1dfe763a84bf737f63056c697a5c79
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00342.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00342")
+public class BenchmarkTest00342 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00342");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00343.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00343.java
new file mode 100644
index 0000000000000000000000000000000000000000..83a704e3644128dfe3f46722777c67e75d652c07
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00343.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00343")
+public class BenchmarkTest00343 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00343");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00344.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00344.java
new file mode 100644
index 0000000000000000000000000000000000000000..18b12f32bbaf45f9211440eff474c91dc3e2e04e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00344.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00344")
+public class BenchmarkTest00344 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest00344");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00345.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00345.java
new file mode 100644
index 0000000000000000000000000000000000000000..b196f6e670cf902913a8e19b7a2045a6cf10759d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00345.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00345")
+public class BenchmarkTest00345 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.io.InputStream param = request.getInputStream();
+
+        java.io.InputStream bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00346.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00346.java
new file mode 100644
index 0000000000000000000000000000000000000000..d8d9052f03452abcbac29171adc8e104cdb9dfc4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00346.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00346")
+public class BenchmarkTest00346 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.io.InputStream param = request.getInputStream();
+
+        java.io.InputStream bar = param;
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00347.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00347.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ab592ac7f4ec9cd664deea23ba66deb89d4f088
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00347.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00347")
+public class BenchmarkTest00347 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.io.InputStream param = request.getInputStream();
+
+        java.io.InputStream bar = param;
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00348.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00348.java
new file mode 100644
index 0000000000000000000000000000000000000000..734f18a1f877c6b0fec8e53583278b02ddc4db5e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00348.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00348")
+public class BenchmarkTest00348 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.io.InputStream param = request.getInputStream();
+
+        java.io.InputStream bar = param;
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00349.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00349.java
new file mode 100644
index 0000000000000000000000000000000000000000..c65929f4144a0de6fe4a5377e6f1a15cecf53e5c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00349.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00349")
+public class BenchmarkTest00349 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.io.InputStream param = request.getInputStream();
+
+        java.io.InputStream bar = param;
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00350.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00350.java
new file mode 100644
index 0000000000000000000000000000000000000000..09e665e5a358c12cc1be2507f79e826808e9af88
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00350.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00350")
+public class BenchmarkTest00350 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00350");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map51742 = new java.util.HashMap<String, Object>();
+        map51742.put("keyA-51742", "a_Value"); // put some stuff in the collection
+        map51742.put("keyB-51742", param); // put it in a collection
+        map51742.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map51742.get("keyB-51742"); // get it back out
+        bar = (String) map51742.get("keyA-51742"); // get safe value back out
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00351.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00351.java
new file mode 100644
index 0000000000000000000000000000000000000000..874f1714a456cf473c0db2f95f18962f4682125d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00351.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00351")
+public class BenchmarkTest00351 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00351");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00352.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00352.java
new file mode 100644
index 0000000000000000000000000000000000000000..9cc86e5185e1ffa662f5da2ec7d8a7c6104e3aea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00352.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00352")
+public class BenchmarkTest00352 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00352");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a98424 = param; // assign
+        StringBuilder b98424 = new StringBuilder(a98424); // stick in stringbuilder
+        b98424.append(" SafeStuff"); // append some safe content
+        b98424.replace(
+                b98424.length() - "Chars".length(),
+                b98424.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map98424 = new java.util.HashMap<String, Object>();
+        map98424.put("key98424", b98424.toString()); // put in a collection
+        String c98424 = (String) map98424.get("key98424"); // get it back out
+        String d98424 = c98424.substring(0, c98424.length() - 1); // extract most of it
+        String e98424 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d98424.getBytes()))); // B64 encode and decode it
+        String f98424 = e98424.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f98424); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00353.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00353.java
new file mode 100644
index 0000000000000000000000000000000000000000..e802513987aab5b22d3254ee25397649e0e5f6ab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00353.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00353")
+public class BenchmarkTest00353 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00353");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map13001 = new java.util.HashMap<String, Object>();
+        map13001.put("keyA-13001", "a_Value"); // put some stuff in the collection
+        map13001.put("keyB-13001", param); // put it in a collection
+        map13001.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map13001.get("keyB-13001"); // get it back out
+        bar = (String) map13001.get("keyA-13001"); // get safe value back out
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00354.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00354.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c385f73a13c7a582c392a3d89fa3d4bd86ceb63
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00354.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00354")
+public class BenchmarkTest00354 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00354");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00355.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00355.java
new file mode 100644
index 0000000000000000000000000000000000000000..044b039008554cb739f1e19fceeb7520868cc835
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00355.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00355")
+public class BenchmarkTest00355 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00355");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a85622 = param; // assign
+        StringBuilder b85622 = new StringBuilder(a85622); // stick in stringbuilder
+        b85622.append(" SafeStuff"); // append some safe content
+        b85622.replace(
+                b85622.length() - "Chars".length(),
+                b85622.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map85622 = new java.util.HashMap<String, Object>();
+        map85622.put("key85622", b85622.toString()); // put in a collection
+        String c85622 = (String) map85622.get("key85622"); // get it back out
+        String d85622 = c85622.substring(0, c85622.length() - 1); // extract most of it
+        String e85622 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d85622.getBytes()))); // B64 encode and decode it
+        String f85622 = e85622.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f85622); // reflection
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00356.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00356.java
new file mode 100644
index 0000000000000000000000000000000000000000..40c187173502dae2cf744de5cba054651bf56719
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00356.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00356")
+public class BenchmarkTest00356 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00356");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00357.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00357.java
new file mode 100644
index 0000000000000000000000000000000000000000..308a7fce4cab690bafeecf0ce89bd95b5e9524cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00357.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00357")
+public class BenchmarkTest00357 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00357");
+        if (param == null) param = "";
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00358.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00358.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8f5a7e9d235c5791dc6c0c85ff5ff125776ecde
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00358.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00358")
+public class BenchmarkTest00358 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00358");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00359.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00359.java
new file mode 100644
index 0000000000000000000000000000000000000000..da6a5a7c3c64e91c4beec0fb5c924c51ba7bde18
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00359.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00359")
+public class BenchmarkTest00359 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00359");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00360.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00360.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6cd88ac32155df64b0b6fde413c57c90f277a60
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00360.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00360")
+public class BenchmarkTest00360 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00360");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00361.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00361.java
new file mode 100644
index 0000000000000000000000000000000000000000..f3cfe7ae4c1a22aee0cfc09e872518290f707881
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00361.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00361")
+public class BenchmarkTest00361 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00361");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00362.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00362.java
new file mode 100644
index 0000000000000000000000000000000000000000..cbc2058cf0cd03ba7dbce6e2a081aa997c610eb6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00362.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00362")
+public class BenchmarkTest00362 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00362");
+        if (param == null) param = "";
+
+        String bar = param;
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00363.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00363.java
new file mode 100644
index 0000000000000000000000000000000000000000..826986955a173dbdf2dae64d8cb257f012b5261a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00363.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00363")
+public class BenchmarkTest00363 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00363");
+        if (param == null) param = "";
+
+        String bar = param;
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00364.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00364.java
new file mode 100644
index 0000000000000000000000000000000000000000..53fbeb1bc1cc28af6dc02856573639e58414e114
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00364.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00364")
+public class BenchmarkTest00364 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00364");
+        if (param == null) param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00365.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00365.java
new file mode 100644
index 0000000000000000000000000000000000000000..38e195fce801083f3211423f1412664b006bcd7b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00365.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00365")
+public class BenchmarkTest00365 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00365");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map10106 = new java.util.HashMap<String, Object>();
+        map10106.put("keyA-10106", "a_Value"); // put some stuff in the collection
+        map10106.put("keyB-10106", param); // put it in a collection
+        map10106.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map10106.get("keyB-10106"); // get it back out
+        bar = (String) map10106.get("keyA-10106"); // get safe value back out
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00366.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00366.java
new file mode 100644
index 0000000000000000000000000000000000000000..802f756cf4dc61194731593b74cb72cd60e48128
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00366.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00366")
+public class BenchmarkTest00366 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00366");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00367.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00367.java
new file mode 100644
index 0000000000000000000000000000000000000000..95d7426939cef505e37c6416b379119790f861f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00367.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00367")
+public class BenchmarkTest00367 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00367");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a12849 = param; // assign
+        StringBuilder b12849 = new StringBuilder(a12849); // stick in stringbuilder
+        b12849.append(" SafeStuff"); // append some safe content
+        b12849.replace(
+                b12849.length() - "Chars".length(),
+                b12849.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map12849 = new java.util.HashMap<String, Object>();
+        map12849.put("key12849", b12849.toString()); // put in a collection
+        String c12849 = (String) map12849.get("key12849"); // get it back out
+        String d12849 = c12849.substring(0, c12849.length() - 1); // extract most of it
+        String e12849 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d12849.getBytes()))); // B64 encode and decode it
+        String f12849 = e12849.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g12849 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g12849); // reflection
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00368.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00368.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea41eb6f4658cd79cfeb7823d487170f8df2b834
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00368.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00368")
+public class BenchmarkTest00368 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00368");
+        if (param == null) param = "";
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00369.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00369.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2e4f9ce144bd05f557b09dc9d4c24cd3cef35eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00369.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00369")
+public class BenchmarkTest00369 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00369");
+        if (param == null) param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00370.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00370.java
new file mode 100644
index 0000000000000000000000000000000000000000..c888c3074894a272fcd8d0523bf66b4131141c2d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00370.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00370")
+public class BenchmarkTest00370 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00370");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00371.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00371.java
new file mode 100644
index 0000000000000000000000000000000000000000..9004e13a45938d6dbaa55e467f674842b5620599
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00371.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00371")
+public class BenchmarkTest00371 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00371");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00372.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00372.java
new file mode 100644
index 0000000000000000000000000000000000000000..c57d2a6503ff4db1098dd19b01785740bd9b5816
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00372.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00372")
+public class BenchmarkTest00372 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00372");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00373.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00373.java
new file mode 100644
index 0000000000000000000000000000000000000000..41e1b6a7f7b5860206ef75b215aa96ca46e7ab48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00373.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00373")
+public class BenchmarkTest00373 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00373");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00374.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00374.java
new file mode 100644
index 0000000000000000000000000000000000000000..73947433ddbe240802686271cf62a57f024ca53d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00374.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00374")
+public class BenchmarkTest00374 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00374");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00375.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00375.java
new file mode 100644
index 0000000000000000000000000000000000000000..98c672792256726560a807cbdd3e329a7f544e0b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00375.java	
@@ -0,0 +1,35 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00375")
+public class BenchmarkTest00375 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00375");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00376.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00376.java
new file mode 100644
index 0000000000000000000000000000000000000000..c590400aaeb03a8adcc1101e6de1ee039ab4e6c6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00376.java	
@@ -0,0 +1,39 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00376")
+public class BenchmarkTest00376 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00376");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00377.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00377.java
new file mode 100644
index 0000000000000000000000000000000000000000..811bed06679ad30b69c375d67974d5a1d216aa39
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00377.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00377")
+public class BenchmarkTest00377 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00377");
+        if (param == null) param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00378.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00378.java
new file mode 100644
index 0000000000000000000000000000000000000000..d070dc10d5e2268e68f2d11f3ca57e3106e29ccc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00378.java	
@@ -0,0 +1,35 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00378")
+public class BenchmarkTest00378 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00378");
+        if (param == null) param = "";
+
+        StringBuilder sbxyz85125 = new StringBuilder(param);
+        String bar = sbxyz85125.append("_SafeStuff").toString();
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00379.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00379.java
new file mode 100644
index 0000000000000000000000000000000000000000..633f83eeb5a0b9b1d82b1f50ff08ad9c64bdaae8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00379.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00379")
+public class BenchmarkTest00379 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00379");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a75704 = param; // assign
+        StringBuilder b75704 = new StringBuilder(a75704); // stick in stringbuilder
+        b75704.append(" SafeStuff"); // append some safe content
+        b75704.replace(
+                b75704.length() - "Chars".length(),
+                b75704.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map75704 = new java.util.HashMap<String, Object>();
+        map75704.put("key75704", b75704.toString()); // put in a collection
+        String c75704 = (String) map75704.get("key75704"); // get it back out
+        String d75704 = c75704.substring(0, c75704.length() - 1); // extract most of it
+        String e75704 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d75704.getBytes()))); // B64 encode and decode it
+        String f75704 = e75704.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g75704 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g75704); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00380.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00380.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a7c039616ed7983c540d57b33b8c3715629ca20
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00380.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00380")
+public class BenchmarkTest00380 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00380");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00381.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00381.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c50ad66556dc7991edf3be1afd979b8355b3aa6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00381.java	
@@ -0,0 +1,34 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00381")
+public class BenchmarkTest00381 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00381");
+        if (param == null) param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00382.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00382.java
new file mode 100644
index 0000000000000000000000000000000000000000..272e9e922fb7872e5a3a764d311eccd5cfb9888a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00382.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00382")
+public class BenchmarkTest00382 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00382");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00383.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00383.java
new file mode 100644
index 0000000000000000000000000000000000000000..b46928270e528368ccd0e10ec2087d3e35449727
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00383.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00383")
+public class BenchmarkTest00383 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00383");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a2196 = param; // assign
+        StringBuilder b2196 = new StringBuilder(a2196); // stick in stringbuilder
+        b2196.append(" SafeStuff"); // append some safe content
+        b2196.replace(
+                b2196.length() - "Chars".length(),
+                b2196.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map2196 = new java.util.HashMap<String, Object>();
+        map2196.put("key2196", b2196.toString()); // put in a collection
+        String c2196 = (String) map2196.get("key2196"); // get it back out
+        String d2196 = c2196.substring(0, c2196.length() - 1); // extract most of it
+        String e2196 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d2196.getBytes()))); // B64 encode and decode it
+        String f2196 = e2196.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f2196); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00384.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00384.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1c1d7ae3d843adb9543f45c05eeafbbdeaa7b32
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00384.java	
@@ -0,0 +1,36 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00384")
+public class BenchmarkTest00384 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00384");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00385.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00385.java
new file mode 100644
index 0000000000000000000000000000000000000000..e709a36f3a2edf20704efe8b30a5854af420e22b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00385.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00385")
+public class BenchmarkTest00385 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00385");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a21475 = param; // assign
+        StringBuilder b21475 = new StringBuilder(a21475); // stick in stringbuilder
+        b21475.append(" SafeStuff"); // append some safe content
+        b21475.replace(
+                b21475.length() - "Chars".length(),
+                b21475.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map21475 = new java.util.HashMap<String, Object>();
+        map21475.put("key21475", b21475.toString()); // put in a collection
+        String c21475 = (String) map21475.get("key21475"); // get it back out
+        String d21475 = c21475.substring(0, c21475.length() - 1); // extract most of it
+        String e21475 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d21475.getBytes()))); // B64 encode and decode it
+        String f21475 = e21475.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f21475); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00386.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00386.java
new file mode 100644
index 0000000000000000000000000000000000000000..de4d63dbaca2aee42306a236e8ce37d9a6c9966c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00386.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00386")
+public class BenchmarkTest00386 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00386");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map8057 = new java.util.HashMap<String, Object>();
+        map8057.put("keyA-8057", "a_Value"); // put some stuff in the collection
+        map8057.put("keyB-8057", param); // put it in a collection
+        map8057.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map8057.get("keyB-8057"); // get it back out
+        bar = (String) map8057.get("keyA-8057"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00387.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00387.java
new file mode 100644
index 0000000000000000000000000000000000000000..536bed917866dee2f8322b5f7d27a7842b3c771c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00387.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00387")
+public class BenchmarkTest00387 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00387");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00388.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00388.java
new file mode 100644
index 0000000000000000000000000000000000000000..f81bf08a4c68b049df58a3f11a4c3c2318e4efb3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00388.java	
@@ -0,0 +1,34 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00388")
+public class BenchmarkTest00388 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00388");
+        if (param == null) param = "";
+
+        StringBuilder sbxyz30382 = new StringBuilder(param);
+        String bar = sbxyz30382.append("_SafeStuff").toString();
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00389.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00389.java
new file mode 100644
index 0000000000000000000000000000000000000000..366d33919561a61e2ab05c3cf8d82e606d7dc9a1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00389.java	
@@ -0,0 +1,33 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00389")
+public class BenchmarkTest00389 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00389");
+        if (param == null) param = "";
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00390.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00390.java
new file mode 100644
index 0000000000000000000000000000000000000000..117bc4397aee58fececba3aa7ed626cc0a99e5f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00390.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00390")
+public class BenchmarkTest00390 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00390");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00391.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00391.java
new file mode 100644
index 0000000000000000000000000000000000000000..40382957fa12ec0c64d9850db6c217ef56078d4e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00391.java	
@@ -0,0 +1,33 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00391")
+public class BenchmarkTest00391 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00391");
+        if (param == null) param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00392.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00392.java
new file mode 100644
index 0000000000000000000000000000000000000000..268fb886070c6e9ee29079004dfff4d761ed2bf8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00392.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00392")
+public class BenchmarkTest00392 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00392");
+        if (param == null) param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz38384 = new StringBuilder(param);
+            bar = sbxyz38384.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00393.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00393.java
new file mode 100644
index 0000000000000000000000000000000000000000..8211dad1bf76c250d8b570c3ab169895ba0c9d08
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00393.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00393")
+public class BenchmarkTest00393 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00393");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00394.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00394.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7ebcfba0bc1ab6beb3dd9b22a8f9d26e651044a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00394.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00394")
+public class BenchmarkTest00394 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00394");
+        if (param == null) param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00395.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00395.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ca2888e1199c2e34f763d176691330ce85eed2f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00395.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00395")
+public class BenchmarkTest00395 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00395");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00396.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00396.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ff8f2def2b5057c90d783c20457945a635f912d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00396.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00396")
+public class BenchmarkTest00396 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00396");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00397.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00397.java
new file mode 100644
index 0000000000000000000000000000000000000000..54b172d7843826e1055ba8dc0daa837a20fa4095
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00397.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00397")
+public class BenchmarkTest00397 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00397");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00398.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00398.java
new file mode 100644
index 0000000000000000000000000000000000000000..a341b5c6653fcc1d8a55b885844ae3ac41db0be4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00398.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00398")
+public class BenchmarkTest00398 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00398");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map43631 = new java.util.HashMap<String, Object>();
+        map43631.put("keyA-43631", "a_Value"); // put some stuff in the collection
+        map43631.put("keyB-43631", param); // put it in a collection
+        map43631.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map43631.get("keyB-43631"); // get it back out
+        bar = (String) map43631.get("keyA-43631"); // get safe value back out
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00399.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00399.java
new file mode 100644
index 0000000000000000000000000000000000000000..3dbbab633d604a7a77ea9ea8281923ac2a36b3a1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00399.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00399")
+public class BenchmarkTest00399 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00399");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a78565 = param; // assign
+        StringBuilder b78565 = new StringBuilder(a78565); // stick in stringbuilder
+        b78565.append(" SafeStuff"); // append some safe content
+        b78565.replace(
+                b78565.length() - "Chars".length(),
+                b78565.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map78565 = new java.util.HashMap<String, Object>();
+        map78565.put("key78565", b78565.toString()); // put in a collection
+        String c78565 = (String) map78565.get("key78565"); // get it back out
+        String d78565 = c78565.substring(0, c78565.length() - 1); // extract most of it
+        String e78565 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d78565.getBytes()))); // B64 encode and decode it
+        String f78565 = e78565.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g78565 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g78565); // reflection
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00400.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00400.java
new file mode 100644
index 0000000000000000000000000000000000000000..3daf0b55a1c31bb9bc948441089c8833bf11c9e3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00400.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00400")
+public class BenchmarkTest00400 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00400");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00401.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00401.java
new file mode 100644
index 0000000000000000000000000000000000000000..884cd9b0f50472624d052d56c75a079df788d8c6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00401.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00401")
+public class BenchmarkTest00401 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00401");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00402.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00402.java
new file mode 100644
index 0000000000000000000000000000000000000000..246b18de91c42bbd95ca207cacf73656b1619c70
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00402.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-00/BenchmarkTest00402")
+public class BenchmarkTest00402 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00402");
+        if (param == null) param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz11630 = new StringBuilder(param);
+            bar = sbxyz11630.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00403.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00403.java
new file mode 100644
index 0000000000000000000000000000000000000000..dec82b6c058a251e5bd7d14ca6089fe88a029d32
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00403.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00403")
+public class BenchmarkTest00403 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00403");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00404.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00404.java
new file mode 100644
index 0000000000000000000000000000000000000000..83975d5e750233d803bc65eee726c56255e27bf8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00404.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00404")
+public class BenchmarkTest00404 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00404");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00405.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00405.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d7cbf25cc2961f1605066d10fdc4e984b5a18e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00405.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00405")
+public class BenchmarkTest00405 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00405");
+        if (param == null) param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00406.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00406.java
new file mode 100644
index 0000000000000000000000000000000000000000..a60242db1f8a5c89183a63c846df5c81aba3a340
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00406.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00406")
+public class BenchmarkTest00406 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00406");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00407.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00407.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e1bfab3eb04758b7477f7d3e0c17dfa49a316c6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00407.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00407")
+public class BenchmarkTest00407 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00407");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00408.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00408.java
new file mode 100644
index 0000000000000000000000000000000000000000..04338a08f9212eece7387f95b1406ea660e6e3a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00408.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00408")
+public class BenchmarkTest00408 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00408");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00409.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00409.java
new file mode 100644
index 0000000000000000000000000000000000000000..40d986159180d0f339e3358f78a22389b7fc9971
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00409.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00409")
+public class BenchmarkTest00409 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00409");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00410.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00410.java
new file mode 100644
index 0000000000000000000000000000000000000000..7bd5d960350e54bfa38a95be2dc8c56067f7f708
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00410.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00410")
+public class BenchmarkTest00410 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00410");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map77851 = new java.util.HashMap<String, Object>();
+        map77851.put("keyA-77851", "a_Value"); // put some stuff in the collection
+        map77851.put("keyB-77851", param); // put it in a collection
+        map77851.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map77851.get("keyB-77851"); // get it back out
+        bar = (String) map77851.get("keyA-77851"); // get safe value back out
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00411.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00411.java
new file mode 100644
index 0000000000000000000000000000000000000000..91b183b362f28e42eccbd8b6cde947d69961bc76
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00411.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00411")
+public class BenchmarkTest00411 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00411");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a18204 = param; // assign
+        StringBuilder b18204 = new StringBuilder(a18204); // stick in stringbuilder
+        b18204.append(" SafeStuff"); // append some safe content
+        b18204.replace(
+                b18204.length() - "Chars".length(),
+                b18204.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map18204 = new java.util.HashMap<String, Object>();
+        map18204.put("key18204", b18204.toString()); // put in a collection
+        String c18204 = (String) map18204.get("key18204"); // get it back out
+        String d18204 = c18204.substring(0, c18204.length() - 1); // extract most of it
+        String e18204 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d18204.getBytes()))); // B64 encode and decode it
+        String f18204 = e18204.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g18204 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g18204); // reflection
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00412.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00412.java
new file mode 100644
index 0000000000000000000000000000000000000000..bdcb9417a20c1721f53b4d759cd2b68550192e2f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00412.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00412")
+public class BenchmarkTest00412 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00412");
+        if (param == null) param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00413.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00413.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bbf656b4094ad59b260141cd6c75fec65bd5580
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00413.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00413")
+public class BenchmarkTest00413 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00413");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map27963 = new java.util.HashMap<String, Object>();
+        map27963.put("keyA-27963", "a-Value"); // put some stuff in the collection
+        map27963.put("keyB-27963", param); // put it in a collection
+        map27963.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map27963.get("keyB-27963"); // get it back out
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00414.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00414.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f5952e60773880f484e0ae932df531868946a0b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00414.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00414")
+public class BenchmarkTest00414 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00414");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00415.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00415.java
new file mode 100644
index 0000000000000000000000000000000000000000..c148e80137b8966a803ea7237cea8859088eff7f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00415.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00415")
+public class BenchmarkTest00415 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00415");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00416.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00416.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7a841f343304317774282a99aed2a185d38c084
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00416.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00416")
+public class BenchmarkTest00416 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00416");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map22488 = new java.util.HashMap<String, Object>();
+        map22488.put("keyA-22488", "a-Value"); // put some stuff in the collection
+        map22488.put("keyB-22488", param); // put it in a collection
+        map22488.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map22488.get("keyB-22488"); // get it back out
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00417.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00417.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d88021b33c8b56007600464c0b31768b8079677
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00417.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00417")
+public class BenchmarkTest00417 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00417");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00418.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00418.java
new file mode 100644
index 0000000000000000000000000000000000000000..1410676618fee04c02066173e5e10501b6facd6e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00418.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00418")
+public class BenchmarkTest00418 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00418");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00419.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00419.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d5ce9e2a5e4dfbd3ddd783979ccdb7e77903647
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00419.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00419")
+public class BenchmarkTest00419 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00419");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00420.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00420.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a8e6046501b2f433d1b1b400ffc6381c3b37b33
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00420.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00420")
+public class BenchmarkTest00420 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00420");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00421.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00421.java
new file mode 100644
index 0000000000000000000000000000000000000000..090fe89d20ca7e1d14dd003f8e27461384124590
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00421.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00421")
+public class BenchmarkTest00421 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00421");
+        if (param == null) param = "";
+
+        String bar = param;
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00422.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00422.java
new file mode 100644
index 0000000000000000000000000000000000000000..229c782035bb6871a310018adb74f29603bee921
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00422.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00422")
+public class BenchmarkTest00422 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00422");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00423.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00423.java
new file mode 100644
index 0000000000000000000000000000000000000000..47601ace48e173be46f86681610e35af57f9d2a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00423.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00423")
+public class BenchmarkTest00423 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00423");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00424.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00424.java
new file mode 100644
index 0000000000000000000000000000000000000000..530a9ab1adeb92849d37cc4e7960dccc1d667cf2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00424.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00424")
+public class BenchmarkTest00424 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00424");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00425.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00425.java
new file mode 100644
index 0000000000000000000000000000000000000000..34e0a2f3089b88665f8f1095381aa0e5bb130621
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00425.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00425")
+public class BenchmarkTest00425 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00425");
+        if (param == null) param = "";
+
+        StringBuilder sbxyz2192 = new StringBuilder(param);
+        String bar = sbxyz2192.append("_SafeStuff").toString();
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00426.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00426.java
new file mode 100644
index 0000000000000000000000000000000000000000..dbfc4dcd2bccf396b82b20051a5a23ea3a8ac34a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00426.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00426")
+public class BenchmarkTest00426 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00426");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00427.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00427.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2da0fe5c8838a2b6dea3f01503c03147f442fbf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00427.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00427")
+public class BenchmarkTest00427 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00427");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a70670 = param; // assign
+        StringBuilder b70670 = new StringBuilder(a70670); // stick in stringbuilder
+        b70670.append(" SafeStuff"); // append some safe content
+        b70670.replace(
+                b70670.length() - "Chars".length(),
+                b70670.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map70670 = new java.util.HashMap<String, Object>();
+        map70670.put("key70670", b70670.toString()); // put in a collection
+        String c70670 = (String) map70670.get("key70670"); // get it back out
+        String d70670 = c70670.substring(0, c70670.length() - 1); // extract most of it
+        String e70670 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d70670.getBytes()))); // B64 encode and decode it
+        String f70670 = e70670.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f70670); // reflection
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00428.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00428.java
new file mode 100644
index 0000000000000000000000000000000000000000..b57a92a6ee959e904dbc07face8f39a2d472e575
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00428.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00428")
+public class BenchmarkTest00428 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00428");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00429.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00429.java
new file mode 100644
index 0000000000000000000000000000000000000000..f339e566b2dd59bb4540137aa3a0779dcc9fbc8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00429.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00429")
+public class BenchmarkTest00429 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00429");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00430.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00430.java
new file mode 100644
index 0000000000000000000000000000000000000000..be18520a17d0fb20d8028f5f31dbb71c3ead31f5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00430.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00430")
+public class BenchmarkTest00430 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00430");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00431.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00431.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea70e19aeff1d62f546790b278b5f57f9bda0b6d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00431.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00431")
+public class BenchmarkTest00431 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00431");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00432.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00432.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c8e3d79787ad1fb5506f33ef09fa53a37136a6c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00432.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00432")
+public class BenchmarkTest00432 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00432");
+        if (param == null) param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00433.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00433.java
new file mode 100644
index 0000000000000000000000000000000000000000..252bfeafe7121ddb57756b47797202f7a26fda2e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00433.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00433")
+public class BenchmarkTest00433 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00433");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00434.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00434.java
new file mode 100644
index 0000000000000000000000000000000000000000..40a29ba0f7c7089bba678308d1667f65c4541eb3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00434.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00434")
+public class BenchmarkTest00434 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00434");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00435.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00435.java
new file mode 100644
index 0000000000000000000000000000000000000000..ada97f8b30b230ceb698297fde9c929719ac912d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00435.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00435")
+public class BenchmarkTest00435 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00435");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map86691 = new java.util.HashMap<String, Object>();
+        map86691.put("keyA-86691", "a-Value"); // put some stuff in the collection
+        map86691.put("keyB-86691", param); // put it in a collection
+        map86691.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map86691.get("keyB-86691"); // get it back out
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00436.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00436.java
new file mode 100644
index 0000000000000000000000000000000000000000..2480e1d2496a58b4d0c9b62042bcb697c5940084
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00436.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00436")
+public class BenchmarkTest00436 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00436");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00437.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00437.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b96196cf4175d93c8ba077c1b39eb9bf5646813
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00437.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00437")
+public class BenchmarkTest00437 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00437");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00438.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00438.java
new file mode 100644
index 0000000000000000000000000000000000000000..2cb70b567128be9b6b213fe67d37c18166731788
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00438.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00438")
+public class BenchmarkTest00438 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00438");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00439.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00439.java
new file mode 100644
index 0000000000000000000000000000000000000000..685fc9a7ca3989f093128aac67d0b097e3f371b1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00439.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00439")
+public class BenchmarkTest00439 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00439");
+        if (param == null) param = "";
+
+        String bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00440.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00440.java
new file mode 100644
index 0000000000000000000000000000000000000000..394ea1a0a3781e1acea1c4b6770336d06ffe4f64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00440.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00440")
+public class BenchmarkTest00440 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00440");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map67409 = new java.util.HashMap<String, Object>();
+        map67409.put("keyA-67409", "a_Value"); // put some stuff in the collection
+        map67409.put("keyB-67409", param); // put it in a collection
+        map67409.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map67409.get("keyB-67409"); // get it back out
+        bar = (String) map67409.get("keyA-67409"); // get safe value back out
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00441.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00441.java
new file mode 100644
index 0000000000000000000000000000000000000000..b85ac0c91c87b263f36c7af8c9af962b4468d48e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00441.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00441")
+public class BenchmarkTest00441 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00441");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00442.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00442.java
new file mode 100644
index 0000000000000000000000000000000000000000..c04eced5009ad3dd036e106ada6d62a9324a6f85
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00442.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00442")
+public class BenchmarkTest00442 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest00442");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00443.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00443.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d4c025b0f74b196107f6c5c675c15478a785f70
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00443.java	
@@ -0,0 +1,140 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00443")
+public class BenchmarkTest00443 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00443");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00444.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00444.java
new file mode 100644
index 0000000000000000000000000000000000000000..bec78f778243eb2f820b4e85322379a32d8fe604
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00444.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00444")
+public class BenchmarkTest00444 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00444");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00445.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00445.java
new file mode 100644
index 0000000000000000000000000000000000000000..345cf61438c2c1bb8ef583952a39a35121ec9c9c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00445.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00445")
+public class BenchmarkTest00445 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00445");
+            if (values != null) param = values[0];
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a98384 = param; // assign
+        StringBuilder b98384 = new StringBuilder(a98384); // stick in stringbuilder
+        b98384.append(" SafeStuff"); // append some safe content
+        b98384.replace(
+                b98384.length() - "Chars".length(),
+                b98384.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map98384 = new java.util.HashMap<String, Object>();
+        map98384.put("key98384", b98384.toString()); // put in a collection
+        String c98384 = (String) map98384.get("key98384"); // get it back out
+        String d98384 = c98384.substring(0, c98384.length() - 1); // extract most of it
+        String e98384 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d98384.getBytes()))); // B64 encode and decode it
+        String f98384 = e98384.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f98384); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00446.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00446.java
new file mode 100644
index 0000000000000000000000000000000000000000..4839e1c0556c4784e0f792ee70774f5f067157f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00446.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00446")
+public class BenchmarkTest00446 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00446");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00447.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00447.java
new file mode 100644
index 0000000000000000000000000000000000000000..ece2800f339156667c7c5f8ec0e1825a0d4c055b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00447.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00447")
+public class BenchmarkTest00447 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00447");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00448.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00448.java
new file mode 100644
index 0000000000000000000000000000000000000000..c139a3ee0b2544491881eaee5929899010d7b682
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00448.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00448")
+public class BenchmarkTest00448 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00448");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00449.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00449.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8e6db60a2733bf202d245e7d0b766e02c73d864
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00449.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00449")
+public class BenchmarkTest00449 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00449");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00450.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00450.java
new file mode 100644
index 0000000000000000000000000000000000000000..745eb59c74a44bee54206274bf550fadedccc843
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00450.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00450")
+public class BenchmarkTest00450 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00450");
+            if (values != null) param = values[0];
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a87006 = param; // assign
+        StringBuilder b87006 = new StringBuilder(a87006); // stick in stringbuilder
+        b87006.append(" SafeStuff"); // append some safe content
+        b87006.replace(
+                b87006.length() - "Chars".length(),
+                b87006.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map87006 = new java.util.HashMap<String, Object>();
+        map87006.put("key87006", b87006.toString()); // put in a collection
+        String c87006 = (String) map87006.get("key87006"); // get it back out
+        String d87006 = c87006.substring(0, c87006.length() - 1); // extract most of it
+        String e87006 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d87006.getBytes()))); // B64 encode and decode it
+        String f87006 = e87006.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f87006); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00451.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00451.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b2207dfc1d0c52bc0ea52382ad6d276afca79e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00451.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00451")
+public class BenchmarkTest00451 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00451");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00452.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00452.java
new file mode 100644
index 0000000000000000000000000000000000000000..2852f1fa302a467b755a7177cd814d8f732f3217
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00452.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00452")
+public class BenchmarkTest00452 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00452");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00453.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00453.java
new file mode 100644
index 0000000000000000000000000000000000000000..75e58ad2fa927b916c6b1e9a32eae889c7fffbd3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00453.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00453")
+public class BenchmarkTest00453 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00453");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00454.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00454.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae9297a5a1d5fd12e00f9c297613a685bdbd4d48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00454.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00454")
+public class BenchmarkTest00454 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00454");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00455.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00455.java
new file mode 100644
index 0000000000000000000000000000000000000000..a4971b545f9c3583f7e11fada2a73dc5b381a7b8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00455.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00455")
+public class BenchmarkTest00455 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00455");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00456.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00456.java
new file mode 100644
index 0000000000000000000000000000000000000000..584a4e907afaa83df5cbc9fc5abc2b9d0e284595
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00456.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00456")
+public class BenchmarkTest00456 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00456");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map49381 = new java.util.HashMap<String, Object>();
+        map49381.put("keyA-49381", "a-Value"); // put some stuff in the collection
+        map49381.put("keyB-49381", param); // put it in a collection
+        map49381.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map49381.get("keyB-49381"); // get it back out
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00457.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00457.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc24c459734c76e56a0def308156bb04d0e15b87
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00457.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00457")
+public class BenchmarkTest00457 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00457");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00458.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00458.java
new file mode 100644
index 0000000000000000000000000000000000000000..557cb039e4cf87a9887d60832998e5c065d6228f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00458.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00458")
+public class BenchmarkTest00458 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00458");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00459.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00459.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce55fafcb137f4de56be95eccb6473147be8865f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00459.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00459")
+public class BenchmarkTest00459 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00459");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00460.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00460.java
new file mode 100644
index 0000000000000000000000000000000000000000..3349f337c05c2d0c8c60f30d32e30115467e3395
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00460.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00460")
+public class BenchmarkTest00460 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00460");
+            if (values != null) param = values[0];
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a62588 = param; // assign
+        StringBuilder b62588 = new StringBuilder(a62588); // stick in stringbuilder
+        b62588.append(" SafeStuff"); // append some safe content
+        b62588.replace(
+                b62588.length() - "Chars".length(),
+                b62588.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map62588 = new java.util.HashMap<String, Object>();
+        map62588.put("key62588", b62588.toString()); // put in a collection
+        String c62588 = (String) map62588.get("key62588"); // get it back out
+        String d62588 = c62588.substring(0, c62588.length() - 1); // extract most of it
+        String e62588 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d62588.getBytes()))); // B64 encode and decode it
+        String f62588 = e62588.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g62588 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g62588); // reflection
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00461.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00461.java
new file mode 100644
index 0000000000000000000000000000000000000000..98baa95722d99bbab38cea89b6650a3e057f5ead
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00461.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00461")
+public class BenchmarkTest00461 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00461");
+            if (values != null) param = values[0];
+        }
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00462.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00462.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2ced368df7b8de5885c37f5b305609565b00ff6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00462.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00462")
+public class BenchmarkTest00462 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00462");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00463.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00463.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed6165377c0622283d3cc81cfbac0d2847695b34
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00463.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00463")
+public class BenchmarkTest00463 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00463");
+            if (values != null) param = values[0];
+        }
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00464.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00464.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7f9dad9e4fc6b8558aab50495dcfe34b0430d61
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00464.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00464")
+public class BenchmarkTest00464 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00464");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00465.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00465.java
new file mode 100644
index 0000000000000000000000000000000000000000..90c82dbaec999d331c5ee930996deb6d1a11f2e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00465.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00465")
+public class BenchmarkTest00465 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00465");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00466.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00466.java
new file mode 100644
index 0000000000000000000000000000000000000000..34a51a6b5e8f5e0c2bac3922cf6c7f41fafc5047
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00466.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00466")
+public class BenchmarkTest00466 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00466");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map46344 = new java.util.HashMap<String, Object>();
+        map46344.put("keyA-46344", "a-Value"); // put some stuff in the collection
+        map46344.put("keyB-46344", param); // put it in a collection
+        map46344.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map46344.get("keyB-46344"); // get it back out
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00467.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00467.java
new file mode 100644
index 0000000000000000000000000000000000000000..08912362664b3cea67809960f0ff6d537b4517a3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00467.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00467")
+public class BenchmarkTest00467 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00467");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map88136 = new java.util.HashMap<String, Object>();
+        map88136.put("keyA-88136", "a-Value"); // put some stuff in the collection
+        map88136.put("keyB-88136", param); // put it in a collection
+        map88136.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map88136.get("keyB-88136"); // get it back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00468.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00468.java
new file mode 100644
index 0000000000000000000000000000000000000000..be5f669440469806bb8ce7e0b8546905b833c2b8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00468.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00468")
+public class BenchmarkTest00468 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00468");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map50379 = new java.util.HashMap<String, Object>();
+        map50379.put("keyA-50379", "a_Value"); // put some stuff in the collection
+        map50379.put("keyB-50379", param); // put it in a collection
+        map50379.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map50379.get("keyB-50379"); // get it back out
+        bar = (String) map50379.get("keyA-50379"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00469.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00469.java
new file mode 100644
index 0000000000000000000000000000000000000000..99b776f606f56ef7944b51eea8fc07dcc41442a8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00469.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00469")
+public class BenchmarkTest00469 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00469");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00470.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00470.java
new file mode 100644
index 0000000000000000000000000000000000000000..b97fbff9afb4721b01322ab5328deba6c2d9baaa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00470.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00470")
+public class BenchmarkTest00470 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00470");
+            if (values != null) param = values[0];
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a1504 = param; // assign
+        StringBuilder b1504 = new StringBuilder(a1504); // stick in stringbuilder
+        b1504.append(" SafeStuff"); // append some safe content
+        b1504.replace(
+                b1504.length() - "Chars".length(),
+                b1504.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map1504 = new java.util.HashMap<String, Object>();
+        map1504.put("key1504", b1504.toString()); // put in a collection
+        String c1504 = (String) map1504.get("key1504"); // get it back out
+        String d1504 = c1504.substring(0, c1504.length() - 1); // extract most of it
+        String e1504 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d1504.getBytes()))); // B64 encode and decode it
+        String f1504 = e1504.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g1504 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g1504); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00471.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00471.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6728e96cab9b8a838f7d3deb476bdc44e078b98
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00471.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00471")
+public class BenchmarkTest00471 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00471");
+            if (values != null) param = values[0];
+        }
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00472.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00472.java
new file mode 100644
index 0000000000000000000000000000000000000000..3027e25deffb8bc89d7534543fc5ca2fd8f1df40
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00472.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00472")
+public class BenchmarkTest00472 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00472");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00473.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00473.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a0307d06422c6ae67f40504166ecd8b2421ad5a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00473.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00473")
+public class BenchmarkTest00473 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00473");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00474.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00474.java
new file mode 100644
index 0000000000000000000000000000000000000000..09c07b0703ea0103fd0e35512b9308300f16b9e9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00474.java	
@@ -0,0 +1,37 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00474")
+public class BenchmarkTest00474 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00474");
+            if (values != null) param = values[0];
+        }
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00475.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00475.java
new file mode 100644
index 0000000000000000000000000000000000000000..faf16a93bd7ff5d60bedb3690e3cfa6379798d28
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00475.java	
@@ -0,0 +1,42 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00475")
+public class BenchmarkTest00475 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00475");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00476.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00476.java
new file mode 100644
index 0000000000000000000000000000000000000000..5330d2d9b8cd71e4a956fc6917db214dce242f8b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00476.java	
@@ -0,0 +1,42 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00476")
+public class BenchmarkTest00476 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00476");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00477.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00477.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bb885dd60f20d467737d7fce9da4a392b8db63a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00477.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00477")
+public class BenchmarkTest00477 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00477");
+            if (values != null) param = values[0];
+        }
+
+        StringBuilder sbxyz54686 = new StringBuilder(param);
+        String bar = sbxyz54686.append("_SafeStuff").toString();
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00478.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00478.java
new file mode 100644
index 0000000000000000000000000000000000000000..adb16fc9a7e0f2eba02ee29308635210f1a90a38
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00478.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00478")
+public class BenchmarkTest00478 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00478");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00479.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00479.java
new file mode 100644
index 0000000000000000000000000000000000000000..878e774f1432470edc3511996db68cdd9205a962
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00479.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00479")
+public class BenchmarkTest00479 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00479");
+            if (values != null) param = values[0];
+        }
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00480.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00480.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bfc10841324082c75b59ad4d608ac14ecfa969f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00480.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00480")
+public class BenchmarkTest00480 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00480");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00481.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00481.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc2f9736d21112dd1e98ef01c2831509a7a8a5a3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00481.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00481")
+public class BenchmarkTest00481 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00481");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00482.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00482.java
new file mode 100644
index 0000000000000000000000000000000000000000..f97543962b6425e42855c1e10cc8c0b182440fca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00482.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00482")
+public class BenchmarkTest00482 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00482");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00483.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00483.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2cc652c7cc74d0b62c92cf16fec38a7bca4a5e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00483.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00483")
+public class BenchmarkTest00483 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00483");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00484.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00484.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b990e8052ae6e435136ac88f07b88e645395235
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00484.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00484")
+public class BenchmarkTest00484 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00484");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00485.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00485.java
new file mode 100644
index 0000000000000000000000000000000000000000..0179724b06018589c2a1b7bd45db09e282f808f8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00485.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00485")
+public class BenchmarkTest00485 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00485");
+            if (values != null) param = values[0];
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00486.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00486.java
new file mode 100644
index 0000000000000000000000000000000000000000..53667c6add6738eed25b606154e32321c7b03234
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00486.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00486")
+public class BenchmarkTest00486 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00486");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00487.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00487.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1dbb5a15cc04bd52feb4630601b541ac80d4cbd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00487.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00487")
+public class BenchmarkTest00487 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00487");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map10732 = new java.util.HashMap<String, Object>();
+        map10732.put("keyA-10732", "a-Value"); // put some stuff in the collection
+        map10732.put("keyB-10732", param); // put it in a collection
+        map10732.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map10732.get("keyB-10732"); // get it back out
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00488.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00488.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f48c2e16aa0f6b145a7f909bf29ab03c4b5a94f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00488.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00488")
+public class BenchmarkTest00488 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00488");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00489.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00489.java
new file mode 100644
index 0000000000000000000000000000000000000000..00a34187ed8df17beb0a97c6fee69b3ecba9ffbe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00489.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00489")
+public class BenchmarkTest00489 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00489");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map25864 = new java.util.HashMap<String, Object>();
+        map25864.put("keyA-25864", "a-Value"); // put some stuff in the collection
+        map25864.put("keyB-25864", param); // put it in a collection
+        map25864.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map25864.get("keyB-25864"); // get it back out
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00490.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00490.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b2756fed65eac864b799aaec71e8b6d4d81f4b7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00490.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00490")
+public class BenchmarkTest00490 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00490");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00491.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00491.java
new file mode 100644
index 0000000000000000000000000000000000000000..9bf630e5ed7a52969bed232cbdeb32e94d16e50b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00491.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00491")
+public class BenchmarkTest00491 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00491");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz92030 = new StringBuilder(param);
+            bar = sbxyz92030.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00492.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00492.java
new file mode 100644
index 0000000000000000000000000000000000000000..78674424b2e76d4bfd3e8907b6b2739f616b14a8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00492.java	
@@ -0,0 +1,39 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00492")
+public class BenchmarkTest00492 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00492");
+            if (values != null) param = values[0];
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00493.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00493.java
new file mode 100644
index 0000000000000000000000000000000000000000..cfaf90b7861276c259381443ae9951141518fd0e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00493.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00493")
+public class BenchmarkTest00493 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00493");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map8943 = new java.util.HashMap<String, Object>();
+        map8943.put("keyA-8943", "a_Value"); // put some stuff in the collection
+        map8943.put("keyB-8943", param); // put it in a collection
+        map8943.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map8943.get("keyB-8943"); // get it back out
+        bar = (String) map8943.get("keyA-8943"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00494.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00494.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e0fb4a98e38528899361f631a337a250ec10ccb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00494.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00494")
+public class BenchmarkTest00494 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00494");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00495.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00495.java
new file mode 100644
index 0000000000000000000000000000000000000000..078b5f9a06c17398bc17bfdda6d790dfbfa8650f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00495.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00495")
+public class BenchmarkTest00495 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00495");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00496.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00496.java
new file mode 100644
index 0000000000000000000000000000000000000000..cfa4ec2aab651b63ebb464a8f7d06cc3825bc8e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00496.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00496")
+public class BenchmarkTest00496 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00496");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00497.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00497.java
new file mode 100644
index 0000000000000000000000000000000000000000..94499bbb1f0fd765a5252644d5f7f05b2c05f7c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00497.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00497")
+public class BenchmarkTest00497 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00497");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00498.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00498.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7afeaf6615bab8e37ada47ac91b7fde29aa7e30
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00498.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00498")
+public class BenchmarkTest00498 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00498");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00499.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00499.java
new file mode 100644
index 0000000000000000000000000000000000000000..d810b0ae5ce21d03400a80a6e9f14f74544f6073
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00499.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00499")
+public class BenchmarkTest00499 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00499");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00500.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00500.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff374f5116bdbc1edacf70b8646156025d7d2e8b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00500.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00500")
+public class BenchmarkTest00500 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00500");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00501.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00501.java
new file mode 100644
index 0000000000000000000000000000000000000000..8aa079aafa8d8ec7919f1a53651d96d0184c0340
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00501.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00501")
+public class BenchmarkTest00501 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00501");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00502.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00502.java
new file mode 100644
index 0000000000000000000000000000000000000000..35f4d3278bbfbd49e2442af1fb237a5a2a5e9a65
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00502.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00502")
+public class BenchmarkTest00502 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00502");
+            if (values != null) param = values[0];
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00503.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00503.java
new file mode 100644
index 0000000000000000000000000000000000000000..40d1d15623a93ba278ded71f442bf226373b1e30
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00503.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00503")
+public class BenchmarkTest00503 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00503");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00504.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00504.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad242b27da0e4232d7b8aac56cb3ddb50c2491d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00504.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00504")
+public class BenchmarkTest00504 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00504");
+            if (values != null) param = values[0];
+        }
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00505.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00505.java
new file mode 100644
index 0000000000000000000000000000000000000000..dec07dc8d9376c29c6ba17e43ee921630af8c01d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00505.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00505")
+public class BenchmarkTest00505 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00505");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map67557 = new java.util.HashMap<String, Object>();
+        map67557.put("keyA-67557", "a-Value"); // put some stuff in the collection
+        map67557.put("keyB-67557", param); // put it in a collection
+        map67557.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map67557.get("keyB-67557"); // get it back out
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00506.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00506.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1548e43b628b9fceb51fed9b09f1b4080dc362b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00506.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00506")
+public class BenchmarkTest00506 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00506");
+            if (values != null) param = values[0];
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a5528 = param; // assign
+        StringBuilder b5528 = new StringBuilder(a5528); // stick in stringbuilder
+        b5528.append(" SafeStuff"); // append some safe content
+        b5528.replace(
+                b5528.length() - "Chars".length(),
+                b5528.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map5528 = new java.util.HashMap<String, Object>();
+        map5528.put("key5528", b5528.toString()); // put in a collection
+        String c5528 = (String) map5528.get("key5528"); // get it back out
+        String d5528 = c5528.substring(0, c5528.length() - 1); // extract most of it
+        String e5528 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d5528.getBytes()))); // B64 encode and decode it
+        String f5528 = e5528.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g5528 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g5528); // reflection
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00507.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00507.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a1de0888375163f7bf7901bcc124344d93761e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00507.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00507")
+public class BenchmarkTest00507 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00507");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00508.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00508.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e9ba3b23f961802013cc53537825c414252ef89
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00508.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00508")
+public class BenchmarkTest00508 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00508");
+            if (values != null) param = values[0];
+        }
+
+        StringBuilder sbxyz10446 = new StringBuilder(param);
+        String bar = sbxyz10446.append("_SafeStuff").toString();
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00509.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00509.java
new file mode 100644
index 0000000000000000000000000000000000000000..229510241504bc7c0f889b5d0b6b6a68da49ca2c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00509.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00509")
+public class BenchmarkTest00509 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00509");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map94841 = new java.util.HashMap<String, Object>();
+        map94841.put("keyA-94841", "a_Value"); // put some stuff in the collection
+        map94841.put("keyB-94841", param); // put it in a collection
+        map94841.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map94841.get("keyB-94841"); // get it back out
+        bar = (String) map94841.get("keyA-94841"); // get safe value back out
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00510.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00510.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c3130b66fff312c37aa74329b6805fa11f2b168
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00510.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-00/BenchmarkTest00510")
+public class BenchmarkTest00510 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00510");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00511.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00511.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f5553c084db734bba19d55aaac808f6306e2727
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00511.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00511")
+public class BenchmarkTest00511 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00511");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map94915 = new java.util.HashMap<String, Object>();
+        map94915.put("keyA-94915", "a_Value"); // put some stuff in the collection
+        map94915.put("keyB-94915", param); // put it in a collection
+        map94915.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map94915.get("keyB-94915"); // get it back out
+        bar = (String) map94915.get("keyA-94915"); // get safe value back out
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00512.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00512.java
new file mode 100644
index 0000000000000000000000000000000000000000..539a47e36aa6e2fbf7e2d5d003ede8b1f0721e3c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00512.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00512")
+public class BenchmarkTest00512 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00512");
+            if (values != null) param = values[0];
+        }
+
+        String bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00513.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00513.java
new file mode 100644
index 0000000000000000000000000000000000000000..af2e425bc00f8936649f879c417e366db83d14c8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00513.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00513")
+public class BenchmarkTest00513 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00513");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map63945 = new java.util.HashMap<String, Object>();
+        map63945.put("keyA-63945", "a_Value"); // put some stuff in the collection
+        map63945.put("keyB-63945", param); // put it in a collection
+        map63945.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map63945.get("keyB-63945"); // get it back out
+        bar = (String) map63945.get("keyA-63945"); // get safe value back out
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00514.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00514.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba968c42b4fb4f5aef0c73104f73ac9566681c99
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00514.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00514")
+public class BenchmarkTest00514 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00514");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00515.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00515.java
new file mode 100644
index 0000000000000000000000000000000000000000..88da9e690e7b974481ff24cee941a4a0debfa63a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00515.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00515")
+public class BenchmarkTest00515 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00515");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00516.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00516.java
new file mode 100644
index 0000000000000000000000000000000000000000..958d7c20fbfd1e7146d8094120b60fc5a49a80a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00516.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00516")
+public class BenchmarkTest00516 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00516");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00517.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00517.java
new file mode 100644
index 0000000000000000000000000000000000000000..a37fb6eb8694d9014f37527cc64251c594ab7c2b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00517.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00517")
+public class BenchmarkTest00517 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00517");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00518.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00518.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf55f79b0350203791c5d9b4b5a48a1d2fee9b8b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00518.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00518")
+public class BenchmarkTest00518 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00518");
+            if (values != null) param = values[0];
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00519.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00519.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab78db4066617b56efcd8f0c1e99eb513f4a4d5f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00519.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00519")
+public class BenchmarkTest00519 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00519");
+            if (values != null) param = values[0];
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map30190 = new java.util.HashMap<String, Object>();
+        map30190.put("keyA-30190", "a_Value"); // put some stuff in the collection
+        map30190.put("keyB-30190", param); // put it in a collection
+        map30190.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map30190.get("keyB-30190"); // get it back out
+        bar = (String) map30190.get("keyA-30190"); // get safe value back out
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00520.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00520.java
new file mode 100644
index 0000000000000000000000000000000000000000..8217c209ea2fd554adcbe91034f5e8d148926b92
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00520.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00520")
+public class BenchmarkTest00520 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest00520");
+            if (values != null) param = values[0];
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00521.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00521.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b2dd8e37a6e76eacc1186de945d7e6061306f79
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00521.java	
@@ -0,0 +1,149 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00521")
+public class BenchmarkTest00521 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00521")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00522.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00522.java
new file mode 100644
index 0000000000000000000000000000000000000000..40bde4a1b25f5b3fa3851d13850de5261f40c23f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00522.java	
@@ -0,0 +1,153 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00522")
+public class BenchmarkTest00522 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00522")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00523.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00523.java
new file mode 100644
index 0000000000000000000000000000000000000000..41a14deccaf5fe70d676b70a81020e3314eb0c66
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00523.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00523")
+public class BenchmarkTest00523 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00523")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a87760 = param; // assign
+        StringBuilder b87760 = new StringBuilder(a87760); // stick in stringbuilder
+        b87760.append(" SafeStuff"); // append some safe content
+        b87760.replace(
+                b87760.length() - "Chars".length(),
+                b87760.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map87760 = new java.util.HashMap<String, Object>();
+        map87760.put("key87760", b87760.toString()); // put in a collection
+        String c87760 = (String) map87760.get("key87760"); // get it back out
+        String d87760 = c87760.substring(0, c87760.length() - 1); // extract most of it
+        String e87760 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d87760.getBytes()))); // B64 encode and decode it
+        String f87760 = e87760.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g87760 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g87760); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00524.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00524.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c0556a9e21ce29c26b1030a89465184370f9fe4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00524.java	
@@ -0,0 +1,135 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00524")
+public class BenchmarkTest00524 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00524")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a18964 = param; // assign
+        StringBuilder b18964 = new StringBuilder(a18964); // stick in stringbuilder
+        b18964.append(" SafeStuff"); // append some safe content
+        b18964.replace(
+                b18964.length() - "Chars".length(),
+                b18964.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map18964 = new java.util.HashMap<String, Object>();
+        map18964.put("key18964", b18964.toString()); // put in a collection
+        String c18964 = (String) map18964.get("key18964"); // get it back out
+        String d18964 = c18964.substring(0, c18964.length() - 1); // extract most of it
+        String e18964 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d18964.getBytes()))); // B64 encode and decode it
+        String f18964 = e18964.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f18964); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00525.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00525.java
new file mode 100644
index 0000000000000000000000000000000000000000..51009034d4330b62b26c18e91573b630064ee0af
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00525.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00525")
+public class BenchmarkTest00525 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00525")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00526.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00526.java
new file mode 100644
index 0000000000000000000000000000000000000000..0584c06ce75e7a62f565fa47ebd46353cf726519
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00526.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00526")
+public class BenchmarkTest00526 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00526")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = param;
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00527.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00527.java
new file mode 100644
index 0000000000000000000000000000000000000000..c958839e74519e269b4db3b318b469d818f479e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00527.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00527")
+public class BenchmarkTest00527 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00527")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00528.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00528.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b6d935e91dcd26d1ca3017dbd54ebc65c754e97
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00528.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00528")
+public class BenchmarkTest00528 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00528")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map6751 = new java.util.HashMap<String, Object>();
+        map6751.put("keyA-6751", "a-Value"); // put some stuff in the collection
+        map6751.put("keyB-6751", param); // put it in a collection
+        map6751.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map6751.get("keyB-6751"); // get it back out
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00529.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00529.java
new file mode 100644
index 0000000000000000000000000000000000000000..98530a29a14a579334eac3b5bee55a19bf7cb177
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00529.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00529")
+public class BenchmarkTest00529 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00529")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = param;
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00530.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00530.java
new file mode 100644
index 0000000000000000000000000000000000000000..c41f194b6f7505c9dc7a986cc5a8a9d25194d248
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00530.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00530")
+public class BenchmarkTest00530 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00530")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00531.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00531.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bae909b7f4a27eea55cf74ae16a06fca6d20393
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00531.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00531")
+public class BenchmarkTest00531 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00531")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map38098 = new java.util.HashMap<String, Object>();
+        map38098.put("keyA-38098", "a-Value"); // put some stuff in the collection
+        map38098.put("keyB-38098", param); // put it in a collection
+        map38098.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map38098.get("keyB-38098"); // get it back out
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00532.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00532.java
new file mode 100644
index 0000000000000000000000000000000000000000..71163dc2f03ffcccf04b576d78cb2acf62cee492
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00532.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00532")
+public class BenchmarkTest00532 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00532")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a25409 = param; // assign
+        StringBuilder b25409 = new StringBuilder(a25409); // stick in stringbuilder
+        b25409.append(" SafeStuff"); // append some safe content
+        b25409.replace(
+                b25409.length() - "Chars".length(),
+                b25409.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map25409 = new java.util.HashMap<String, Object>();
+        map25409.put("key25409", b25409.toString()); // put in a collection
+        String c25409 = (String) map25409.get("key25409"); // get it back out
+        String d25409 = c25409.substring(0, c25409.length() - 1); // extract most of it
+        String e25409 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d25409.getBytes()))); // B64 encode and decode it
+        String f25409 = e25409.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f25409); // reflection
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00533.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00533.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8aa7e248408bdb7688663a85e839835a218f34e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00533.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00533")
+public class BenchmarkTest00533 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00533")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00534.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00534.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3384a247e5a16189c0b45f28a1acfd9b6817308
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00534.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00534")
+public class BenchmarkTest00534 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00534")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00535.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00535.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5d253a8e3a1f041552dfd3d1f9e398b9c5f2f9b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00535.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00535")
+public class BenchmarkTest00535 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00535")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00536.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00536.java
new file mode 100644
index 0000000000000000000000000000000000000000..c77f04e36b8169ae96bfdf3025e7717de68e32a2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00536.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00536")
+public class BenchmarkTest00536 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00536")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map28714 = new java.util.HashMap<String, Object>();
+        map28714.put("keyA-28714", "a-Value"); // put some stuff in the collection
+        map28714.put("keyB-28714", param); // put it in a collection
+        map28714.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map28714.get("keyB-28714"); // get it back out
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00537.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00537.java
new file mode 100644
index 0000000000000000000000000000000000000000..ddf26170368901f926cde0e3498fcee6d43d7e1d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00537.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00537")
+public class BenchmarkTest00537 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00537")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00538.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00538.java
new file mode 100644
index 0000000000000000000000000000000000000000..869ca0c13032e2252617994d66f4888aa08c9306
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00538.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00538")
+public class BenchmarkTest00538 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00538")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a75053 = param; // assign
+        StringBuilder b75053 = new StringBuilder(a75053); // stick in stringbuilder
+        b75053.append(" SafeStuff"); // append some safe content
+        b75053.replace(
+                b75053.length() - "Chars".length(),
+                b75053.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map75053 = new java.util.HashMap<String, Object>();
+        map75053.put("key75053", b75053.toString()); // put in a collection
+        String c75053 = (String) map75053.get("key75053"); // get it back out
+        String d75053 = c75053.substring(0, c75053.length() - 1); // extract most of it
+        String e75053 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d75053.getBytes()))); // B64 encode and decode it
+        String f75053 = e75053.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f75053); // reflection
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00539.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00539.java
new file mode 100644
index 0000000000000000000000000000000000000000..7284c2fc9cbffeaf3936109fb7075152a49e2097
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00539.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00539")
+public class BenchmarkTest00539 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00539")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00540.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00540.java
new file mode 100644
index 0000000000000000000000000000000000000000..88a1a4768c31b5c8c2ba5cc03db0d1002c4239c2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00540.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00540")
+public class BenchmarkTest00540 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00540")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00541.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00541.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1c620948a2eb459fa465c0ea2f42965c1c923f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00541.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00541")
+public class BenchmarkTest00541 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00541")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00542.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00542.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb523e5b9327fea45603c296bdc0d5bfc712bf79
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00542.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00542")
+public class BenchmarkTest00542 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00542")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00543.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00543.java
new file mode 100644
index 0000000000000000000000000000000000000000..a90968b26a78b2344b6f6272cab15479181a952f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00543.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-00/BenchmarkTest00543")
+public class BenchmarkTest00543 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00543")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00544.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00544.java
new file mode 100644
index 0000000000000000000000000000000000000000..48ae4e3ea811e836e1ce8adde68eb2cba6fb5c9b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00544.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00544")
+public class BenchmarkTest00544 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00544")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00545.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00545.java
new file mode 100644
index 0000000000000000000000000000000000000000..feb3e626281e5d4a101af9a3c78274074d25e63c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00545.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00545")
+public class BenchmarkTest00545 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00545")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a80566 = param; // assign
+        StringBuilder b80566 = new StringBuilder(a80566); // stick in stringbuilder
+        b80566.append(" SafeStuff"); // append some safe content
+        b80566.replace(
+                b80566.length() - "Chars".length(),
+                b80566.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map80566 = new java.util.HashMap<String, Object>();
+        map80566.put("key80566", b80566.toString()); // put in a collection
+        String c80566 = (String) map80566.get("key80566"); // get it back out
+        String d80566 = c80566.substring(0, c80566.length() - 1); // extract most of it
+        String e80566 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d80566.getBytes()))); // B64 encode and decode it
+        String f80566 = e80566.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g80566 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g80566); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00546.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00546.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c43158b0a28ae0713987e09adba916c7390f98e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00546.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00546")
+public class BenchmarkTest00546 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00546")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00547.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00547.java
new file mode 100644
index 0000000000000000000000000000000000000000..e249b6499e2a7f9535f5105dd1a0ac9d7a72a6b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00547.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00547")
+public class BenchmarkTest00547 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00547")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00548.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00548.java
new file mode 100644
index 0000000000000000000000000000000000000000..0dd8246609cc4e03838445f8cb429b5d3bc4c455
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00548.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00548")
+public class BenchmarkTest00548 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00548")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a52901 = param; // assign
+        StringBuilder b52901 = new StringBuilder(a52901); // stick in stringbuilder
+        b52901.append(" SafeStuff"); // append some safe content
+        b52901.replace(
+                b52901.length() - "Chars".length(),
+                b52901.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map52901 = new java.util.HashMap<String, Object>();
+        map52901.put("key52901", b52901.toString()); // put in a collection
+        String c52901 = (String) map52901.get("key52901"); // get it back out
+        String d52901 = c52901.substring(0, c52901.length() - 1); // extract most of it
+        String e52901 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d52901.getBytes()))); // B64 encode and decode it
+        String f52901 = e52901.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g52901 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g52901); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00549.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00549.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c756c08ddd56fd42b469a47666c9179c2d04faa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00549.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00549")
+public class BenchmarkTest00549 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00549")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00550.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00550.java
new file mode 100644
index 0000000000000000000000000000000000000000..115dbccc13df7584b4e360b5bfd9806ac03031d6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00550.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00550")
+public class BenchmarkTest00550 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00550")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00551.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00551.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c284bda5a663a7fbf25efd457208e95cdac4c2e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00551.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00551")
+public class BenchmarkTest00551 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00551")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00552.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00552.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3522ad3bf1c4b8cf4007cefd6dbc5158caedd57
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00552.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00552")
+public class BenchmarkTest00552 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00552")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map63597 = new java.util.HashMap<String, Object>();
+        map63597.put("keyA-63597", "a-Value"); // put some stuff in the collection
+        map63597.put("keyB-63597", param); // put it in a collection
+        map63597.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map63597.get("keyB-63597"); // get it back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00553.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00553.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c4dace4a6f7befa2a7d5bc259757301b9d3faa3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00553.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00553")
+public class BenchmarkTest00553 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00553")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00554.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00554.java
new file mode 100644
index 0000000000000000000000000000000000000000..21c1e8cc2fe3adb4ede63f0305da0e618ea5ab51
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00554.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00554")
+public class BenchmarkTest00554 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00554")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00555.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00555.java
new file mode 100644
index 0000000000000000000000000000000000000000..efd2ed8e1ddecad75eb8d80a1f69cf80ba8c0b73
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00555.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00555")
+public class BenchmarkTest00555 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00555")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00556.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00556.java
new file mode 100644
index 0000000000000000000000000000000000000000..61a8e7e590aa8d29a742d1ccbe21e8faa6a9cd31
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00556.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00556")
+public class BenchmarkTest00556 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00556")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00557.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00557.java
new file mode 100644
index 0000000000000000000000000000000000000000..c50355befcd0fc3152815a12338cac339a7581ea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00557.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00557")
+public class BenchmarkTest00557 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00557")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00558.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00558.java
new file mode 100644
index 0000000000000000000000000000000000000000..f3122d0044b46284a3f8151905867da0201efaa4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00558.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00558")
+public class BenchmarkTest00558 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00558")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00559.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00559.java
new file mode 100644
index 0000000000000000000000000000000000000000..648928233f5caf153fc1d722f7e0700e6b7cee94
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00559.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00559")
+public class BenchmarkTest00559 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00559")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a39502 = param; // assign
+        StringBuilder b39502 = new StringBuilder(a39502); // stick in stringbuilder
+        b39502.append(" SafeStuff"); // append some safe content
+        b39502.replace(
+                b39502.length() - "Chars".length(),
+                b39502.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map39502 = new java.util.HashMap<String, Object>();
+        map39502.put("key39502", b39502.toString()); // put in a collection
+        String c39502 = (String) map39502.get("key39502"); // get it back out
+        String d39502 = c39502.substring(0, c39502.length() - 1); // extract most of it
+        String e39502 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d39502.getBytes()))); // B64 encode and decode it
+        String f39502 = e39502.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g39502 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g39502); // reflection
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00560.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00560.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c5561ad5c34f88e731cc8f607f4d5ff2a00c21a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00560.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00560")
+public class BenchmarkTest00560 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00560")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00561.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00561.java
new file mode 100644
index 0000000000000000000000000000000000000000..18fbe72470b69d61c0c3c11494e50fc305fb330f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00561.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00561")
+public class BenchmarkTest00561 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00561")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00562.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00562.java
new file mode 100644
index 0000000000000000000000000000000000000000..0806d65c6823f9a6b8c67fdad035657796e63413
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00562.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00562")
+public class BenchmarkTest00562 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00562")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00563.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00563.java
new file mode 100644
index 0000000000000000000000000000000000000000..cae5aedeec821c5cb8411948faae9c87b9844163
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00563.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00563")
+public class BenchmarkTest00563 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00563")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = param;
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00564.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00564.java
new file mode 100644
index 0000000000000000000000000000000000000000..80867e763238497e0e1cd4d90f526ccb6be60cbf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00564.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00564")
+public class BenchmarkTest00564 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00564")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        StringBuilder sbxyz41882 = new StringBuilder(param);
+        String bar = sbxyz41882.append("_SafeStuff").toString();
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00565.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00565.java
new file mode 100644
index 0000000000000000000000000000000000000000..775a038f38201c873ef7bb327cc007d854965b9a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00565.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00565")
+public class BenchmarkTest00565 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00565")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00566.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00566.java
new file mode 100644
index 0000000000000000000000000000000000000000..13e7fff3a432d72f009af1684da1c3889d785106
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00566.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00566")
+public class BenchmarkTest00566 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00566")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00567.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00567.java
new file mode 100644
index 0000000000000000000000000000000000000000..1869cf986deb4b2b393c02485e230adbd0d59e54
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00567.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00567")
+public class BenchmarkTest00567 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00567")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00568.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00568.java
new file mode 100644
index 0000000000000000000000000000000000000000..44007296a1ee0ef9e4f4d9e33a79f1856bbec3e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00568.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00568")
+public class BenchmarkTest00568 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00568")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00569.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00569.java
new file mode 100644
index 0000000000000000000000000000000000000000..56abb3efe5ef6e42a0d7e04d5a69d27af0831fbd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00569.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00569")
+public class BenchmarkTest00569 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00569")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a6821 = param; // assign
+        StringBuilder b6821 = new StringBuilder(a6821); // stick in stringbuilder
+        b6821.append(" SafeStuff"); // append some safe content
+        b6821.replace(
+                b6821.length() - "Chars".length(),
+                b6821.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map6821 = new java.util.HashMap<String, Object>();
+        map6821.put("key6821", b6821.toString()); // put in a collection
+        String c6821 = (String) map6821.get("key6821"); // get it back out
+        String d6821 = c6821.substring(0, c6821.length() - 1); // extract most of it
+        String e6821 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d6821.getBytes()))); // B64 encode and decode it
+        String f6821 = e6821.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g6821 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g6821); // reflection
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00570.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00570.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5065ab784a38efe172e9957793481971ed144cb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00570.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00570")
+public class BenchmarkTest00570 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00570")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00571.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00571.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8e7cc6a842538ee279c240f7a87a2ad73e7c615
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00571.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00571")
+public class BenchmarkTest00571 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00571")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00572.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00572.java
new file mode 100644
index 0000000000000000000000000000000000000000..944be57e2106b066d28d5b5ac64934f3623ff12e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00572.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00572")
+public class BenchmarkTest00572 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00572")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00573.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00573.java
new file mode 100644
index 0000000000000000000000000000000000000000..224128f42cb651d48f21c995144e5d364c748dff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00573.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00573")
+public class BenchmarkTest00573 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00573")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = param;
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00574.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00574.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ec9eade6e241960953d92510af3345a5d81c6b1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00574.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00574")
+public class BenchmarkTest00574 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00574")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00575.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00575.java
new file mode 100644
index 0000000000000000000000000000000000000000..34f59730f10e1fd193e9b62c2a848a4333475cae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00575.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00575")
+public class BenchmarkTest00575 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00575")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00576.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00576.java
new file mode 100644
index 0000000000000000000000000000000000000000..885c34b78caa416b2e18f3b8e1f8ed91449fafb2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00576.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00576")
+public class BenchmarkTest00576 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00576")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00577.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00577.java
new file mode 100644
index 0000000000000000000000000000000000000000..17c051c9a6c0e98e075c895368a946d0f327e8fb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00577.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00577")
+public class BenchmarkTest00577 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00577")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00578.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00578.java
new file mode 100644
index 0000000000000000000000000000000000000000..b466b93f3dc4ef2c55f5b8f0397280a2d11cad39
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00578.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00578")
+public class BenchmarkTest00578 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00578")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00579.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00579.java
new file mode 100644
index 0000000000000000000000000000000000000000..40d58f8618e8aceee7889454d18b5fd4906d7987
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00579.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00579")
+public class BenchmarkTest00579 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00579")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00580.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00580.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8b16353b8ac29983dc4f7ffeb5b1d176239c63e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00580.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00580")
+public class BenchmarkTest00580 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00580")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00581.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00581.java
new file mode 100644
index 0000000000000000000000000000000000000000..21e2e7e0ca0dffba59732102299cfc4f54c9b2ac
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00581.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00581")
+public class BenchmarkTest00581 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00581")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00582.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00582.java
new file mode 100644
index 0000000000000000000000000000000000000000..226468cdc775d59bc6a1d945f6649bebcdbe5718
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00582.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00582")
+public class BenchmarkTest00582 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00582")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00583.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00583.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c4b390bf2d8dd8fc091b44898fcfa6a4d0991cf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00583.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00583")
+public class BenchmarkTest00583 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00583")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00584.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00584.java
new file mode 100644
index 0000000000000000000000000000000000000000..50964d13676d55c3478d32c3434bb3513df10f21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00584.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00584")
+public class BenchmarkTest00584 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00584")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map23020 = new java.util.HashMap<String, Object>();
+        map23020.put("keyA-23020", "a_Value"); // put some stuff in the collection
+        map23020.put("keyB-23020", param); // put it in a collection
+        map23020.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map23020.get("keyB-23020"); // get it back out
+        bar = (String) map23020.get("keyA-23020"); // get safe value back out
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00585.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00585.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4945cb0ca24cfbb01d9226fc3683536e1ee7cc4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00585.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00585")
+public class BenchmarkTest00585 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00585")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        StringBuilder sbxyz49441 = new StringBuilder(param);
+        String bar = sbxyz49441.append("_SafeStuff").toString();
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00586.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00586.java
new file mode 100644
index 0000000000000000000000000000000000000000..979c1cde156d68ca5f51d09d3fef47918d694533
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00586.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00586")
+public class BenchmarkTest00586 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00586")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map58886 = new java.util.HashMap<String, Object>();
+        map58886.put("keyA-58886", "a_Value"); // put some stuff in the collection
+        map58886.put("keyB-58886", param); // put it in a collection
+        map58886.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map58886.get("keyB-58886"); // get it back out
+        bar = (String) map58886.get("keyA-58886"); // get safe value back out
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00587.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00587.java
new file mode 100644
index 0000000000000000000000000000000000000000..2af9d1502f1c521034c693215048023f0939329f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00587.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00587")
+public class BenchmarkTest00587 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00587")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map44465 = new java.util.HashMap<String, Object>();
+        map44465.put("keyA-44465", "a-Value"); // put some stuff in the collection
+        map44465.put("keyB-44465", param); // put it in a collection
+        map44465.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map44465.get("keyB-44465"); // get it back out
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00588.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00588.java
new file mode 100644
index 0000000000000000000000000000000000000000..b070da82651c74b38c64aaf08f6d567301281034
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00588.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00588")
+public class BenchmarkTest00588 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00588")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00589.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00589.java
new file mode 100644
index 0000000000000000000000000000000000000000..6edc5ac04ce23cc5ecb8a0e80e44aea18ffd4276
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00589.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00589")
+public class BenchmarkTest00589 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00589")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00590.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00590.java
new file mode 100644
index 0000000000000000000000000000000000000000..1391e738c0e3c55b650fd95d7404c1a19c1ad1c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00590.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00590")
+public class BenchmarkTest00590 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00590")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00591.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00591.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5314016892f7ea9a025d6af7b07c7111b91f4fc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00591.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00591")
+public class BenchmarkTest00591 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00591")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00592.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00592.java
new file mode 100644
index 0000000000000000000000000000000000000000..b20804972d1035bba2490a403b49726d721e122b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00592.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00592")
+public class BenchmarkTest00592 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00592")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a36502 = param; // assign
+        StringBuilder b36502 = new StringBuilder(a36502); // stick in stringbuilder
+        b36502.append(" SafeStuff"); // append some safe content
+        b36502.replace(
+                b36502.length() - "Chars".length(),
+                b36502.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map36502 = new java.util.HashMap<String, Object>();
+        map36502.put("key36502", b36502.toString()); // put in a collection
+        String c36502 = (String) map36502.get("key36502"); // get it back out
+        String d36502 = c36502.substring(0, c36502.length() - 1); // extract most of it
+        String e36502 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d36502.getBytes()))); // B64 encode and decode it
+        String f36502 = e36502.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g36502 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g36502); // reflection
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00593.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00593.java
new file mode 100644
index 0000000000000000000000000000000000000000..bdae043e681b645eca42c207b5e99c2a3af9cb13
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00593.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00593")
+public class BenchmarkTest00593 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00593")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00594.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00594.java
new file mode 100644
index 0000000000000000000000000000000000000000..59e82779e6ea87a5a07fa8859288b95660f015e4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00594.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00594")
+public class BenchmarkTest00594 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00594")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map29056 = new java.util.HashMap<String, Object>();
+        map29056.put("keyA-29056", "a-Value"); // put some stuff in the collection
+        map29056.put("keyB-29056", param); // put it in a collection
+        map29056.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map29056.get("keyB-29056"); // get it back out
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00595.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00595.java
new file mode 100644
index 0000000000000000000000000000000000000000..1cc7db5dbf5957b6dbbfda3d02d494315ec697c4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00595.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00595")
+public class BenchmarkTest00595 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00595")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00596.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00596.java
new file mode 100644
index 0000000000000000000000000000000000000000..906868f75bb720f7ec27be84f83de6003d731473
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00596.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00596")
+public class BenchmarkTest00596 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00596")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00597.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00597.java
new file mode 100644
index 0000000000000000000000000000000000000000..76a2dcf00fb26c32521db5bf075bd63e59a9c9e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00597.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00597")
+public class BenchmarkTest00597 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00597")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00598.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00598.java
new file mode 100644
index 0000000000000000000000000000000000000000..df4a154e01f5fdcd064a234fd5b1661e5adac9ca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00598.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00598")
+public class BenchmarkTest00598 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00598")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00599.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00599.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ba9ab414aae36690cc013908b3664f67396dd6c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00599.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00599")
+public class BenchmarkTest00599 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00599")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        // Chain a bunch of propagators in sequence
+        String a99467 = param; // assign
+        StringBuilder b99467 = new StringBuilder(a99467); // stick in stringbuilder
+        b99467.append(" SafeStuff"); // append some safe content
+        b99467.replace(
+                b99467.length() - "Chars".length(),
+                b99467.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map99467 = new java.util.HashMap<String, Object>();
+        map99467.put("key99467", b99467.toString()); // put in a collection
+        String c99467 = (String) map99467.get("key99467"); // get it back out
+        String d99467 = c99467.substring(0, c99467.length() - 1); // extract most of it
+        String e99467 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d99467.getBytes()))); // B64 encode and decode it
+        String f99467 = e99467.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g99467 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g99467); // reflection
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00600.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00600.java
new file mode 100644
index 0000000000000000000000000000000000000000..c836e7e2a6939fbc1e997f1864c0a7f6fe706bb1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00600.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00600")
+public class BenchmarkTest00600 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00600")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00601.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00601.java
new file mode 100644
index 0000000000000000000000000000000000000000..b4a6af018a9995c48c83ad10d8abef11764fd748
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00601.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00601")
+public class BenchmarkTest00601 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00601")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00602.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00602.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f6fdca69e01ae7fbf0e805ff7d6d12820ba3660
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00602.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00602")
+public class BenchmarkTest00602 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00602")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00603.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00603.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4b92134282c09a21ad823b85947fe86458736f5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00603.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00603")
+public class BenchmarkTest00603 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00603")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00604.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00604.java
new file mode 100644
index 0000000000000000000000000000000000000000..34835d4d204a32c880c19b0e04b7cdb952fe83d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00604.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00604")
+public class BenchmarkTest00604 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00604")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00605.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00605.java
new file mode 100644
index 0000000000000000000000000000000000000000..10277d1e28b8c1dd021f72a2ba9da473968120a7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00605.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00605")
+public class BenchmarkTest00605 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00605")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00606.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00606.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b9802cf3e18ee5e2d1faf52a83362a8da3f3f1b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00606.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00606")
+public class BenchmarkTest00606 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00606")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00607.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00607.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c69e61c7d272a15176b6e37844774913ff18c21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00607.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00607")
+public class BenchmarkTest00607 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest00607")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00608.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00608.java
new file mode 100644
index 0000000000000000000000000000000000000000..03333cc095f238f61ea51caeefe3613ac4a63834
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00608.java	
@@ -0,0 +1,142 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00608")
+public class BenchmarkTest00608 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00608");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00609.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00609.java
new file mode 100644
index 0000000000000000000000000000000000000000..72b17f1a36c941dba23690b24773f94cce1c1582
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00609.java	
@@ -0,0 +1,134 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00609")
+public class BenchmarkTest00609 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00609");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00610.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00610.java
new file mode 100644
index 0000000000000000000000000000000000000000..4347d1ebdaa74b1a632bb8e04707be95ed1c2207
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00610.java	
@@ -0,0 +1,153 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00610")
+public class BenchmarkTest00610 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00610");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a51289 = param; // assign
+        StringBuilder b51289 = new StringBuilder(a51289); // stick in stringbuilder
+        b51289.append(" SafeStuff"); // append some safe content
+        b51289.replace(
+                b51289.length() - "Chars".length(),
+                b51289.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map51289 = new java.util.HashMap<String, Object>();
+        map51289.put("key51289", b51289.toString()); // put in a collection
+        String c51289 = (String) map51289.get("key51289"); // get it back out
+        String d51289 = c51289.substring(0, c51289.length() - 1); // extract most of it
+        String e51289 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d51289.getBytes()))); // B64 encode and decode it
+        String f51289 = e51289.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g51289 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g51289); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00611.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00611.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e45306a9d4565255dc01e10b86210e401bc8ceb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00611.java	
@@ -0,0 +1,137 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00611")
+public class BenchmarkTest00611 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00611");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00612.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00612.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1b97ca90b74381d0a4025cb28dbdc8d88317551
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00612.java	
@@ -0,0 +1,138 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00612")
+public class BenchmarkTest00612 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00612");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00613.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00613.java
new file mode 100644
index 0000000000000000000000000000000000000000..40181fdf65ae04a78e3086c9bdea1be1f108dd69
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00613.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00613")
+public class BenchmarkTest00613 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00613");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map67704 = new java.util.HashMap<String, Object>();
+        map67704.put("keyA-67704", "a_Value"); // put some stuff in the collection
+        map67704.put("keyB-67704", param); // put it in a collection
+        map67704.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map67704.get("keyB-67704"); // get it back out
+        bar = (String) map67704.get("keyA-67704"); // get safe value back out
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00614.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00614.java
new file mode 100644
index 0000000000000000000000000000000000000000..be917b0daf627690e730c550caa26f5120f873fe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00614.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00614")
+public class BenchmarkTest00614 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00614");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00615.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00615.java
new file mode 100644
index 0000000000000000000000000000000000000000..6135e3c3547a604c32d17052b41844dfbc1c23d3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00615.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00615")
+public class BenchmarkTest00615 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00615");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map4123 = new java.util.HashMap<String, Object>();
+        map4123.put("keyA-4123", "a_Value"); // put some stuff in the collection
+        map4123.put("keyB-4123", param); // put it in a collection
+        map4123.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map4123.get("keyB-4123"); // get it back out
+        bar = (String) map4123.get("keyA-4123"); // get safe value back out
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00616.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00616.java
new file mode 100644
index 0000000000000000000000000000000000000000..157a37f4fd5fa67bbd9893c1a2f07d73b3ae0f77
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00616.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00616")
+public class BenchmarkTest00616 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00616");
+        if (param == null) param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00617.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00617.java
new file mode 100644
index 0000000000000000000000000000000000000000..bfc34623a791c5bd5524109f68a2345ccbc2d5de
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00617.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00617")
+public class BenchmarkTest00617 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00617");
+        if (param == null) param = "";
+
+        StringBuilder sbxyz57328 = new StringBuilder(param);
+        String bar = sbxyz57328.append("_SafeStuff").toString();
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00618.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00618.java
new file mode 100644
index 0000000000000000000000000000000000000000..a75364053e0a603a9ce0efd51556382cf46509cf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00618.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00618")
+public class BenchmarkTest00618 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00618");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00619.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00619.java
new file mode 100644
index 0000000000000000000000000000000000000000..13a7767718a60da4c1049e80896d2c56c83b86d9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00619.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00619")
+public class BenchmarkTest00619 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00619");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00620.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00620.java
new file mode 100644
index 0000000000000000000000000000000000000000..9aa5b3e9e50eddc9250268c8218989f5f9229cfe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00620.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00620")
+public class BenchmarkTest00620 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00620");
+        if (param == null) param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00621.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00621.java
new file mode 100644
index 0000000000000000000000000000000000000000..23ece65367d50a8dafe61ad1e1ac50c3aa6d16ed
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00621.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00621")
+public class BenchmarkTest00621 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00621");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a28566 = param; // assign
+        StringBuilder b28566 = new StringBuilder(a28566); // stick in stringbuilder
+        b28566.append(" SafeStuff"); // append some safe content
+        b28566.replace(
+                b28566.length() - "Chars".length(),
+                b28566.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map28566 = new java.util.HashMap<String, Object>();
+        map28566.put("key28566", b28566.toString()); // put in a collection
+        String c28566 = (String) map28566.get("key28566"); // get it back out
+        String d28566 = c28566.substring(0, c28566.length() - 1); // extract most of it
+        String e28566 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d28566.getBytes()))); // B64 encode and decode it
+        String f28566 = e28566.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g28566 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g28566); // reflection
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00622.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00622.java
new file mode 100644
index 0000000000000000000000000000000000000000..6dc3d18eba04019caa3dd280d5254c562a627e09
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00622.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00622")
+public class BenchmarkTest00622 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00622");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00623.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00623.java
new file mode 100644
index 0000000000000000000000000000000000000000..97ca5aa9e3fb5366bab227f5380904a68b0e7bcb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00623.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00623")
+public class BenchmarkTest00623 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00623");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00624.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00624.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c1eef1d77ae6417348b52c0673b668f58e6ccc7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00624.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00624")
+public class BenchmarkTest00624 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00624");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00625.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00625.java
new file mode 100644
index 0000000000000000000000000000000000000000..df19d54dd4766e23928cf691d4fc60bfe7da099a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00625.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00625")
+public class BenchmarkTest00625 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00625");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00626.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00626.java
new file mode 100644
index 0000000000000000000000000000000000000000..64653c02344dc78a1bd0cf6b35a2c017912591f3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00626.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00626")
+public class BenchmarkTest00626 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00626");
+        if (param == null) param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00627.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00627.java
new file mode 100644
index 0000000000000000000000000000000000000000..f32140d558761d258d71913c5b7ab4c3c8ce1a35
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00627.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00627")
+public class BenchmarkTest00627 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00627");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00628.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00628.java
new file mode 100644
index 0000000000000000000000000000000000000000..80373351647954e7642623b56c254f143959d9e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00628.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00628")
+public class BenchmarkTest00628 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00628");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a24315 = param; // assign
+        StringBuilder b24315 = new StringBuilder(a24315); // stick in stringbuilder
+        b24315.append(" SafeStuff"); // append some safe content
+        b24315.replace(
+                b24315.length() - "Chars".length(),
+                b24315.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map24315 = new java.util.HashMap<String, Object>();
+        map24315.put("key24315", b24315.toString()); // put in a collection
+        String c24315 = (String) map24315.get("key24315"); // get it back out
+        String d24315 = c24315.substring(0, c24315.length() - 1); // extract most of it
+        String e24315 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d24315.getBytes()))); // B64 encode and decode it
+        String f24315 = e24315.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g24315 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g24315); // reflection
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00629.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00629.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f8651e3a530942f68ffb916153b4622868d7caa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00629.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00629")
+public class BenchmarkTest00629 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00629");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00630.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00630.java
new file mode 100644
index 0000000000000000000000000000000000000000..a17e1caaa4464d60c8afb69a801cb247df592baa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00630.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00630")
+public class BenchmarkTest00630 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00630");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00631.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00631.java
new file mode 100644
index 0000000000000000000000000000000000000000..5cf8df3d76603fc2ae82f4c19c574db490391c66
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00631.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00631")
+public class BenchmarkTest00631 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00631");
+        if (param == null) param = "";
+
+        StringBuilder sbxyz28895 = new StringBuilder(param);
+        String bar = sbxyz28895.append("_SafeStuff").toString();
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00632.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00632.java
new file mode 100644
index 0000000000000000000000000000000000000000..523ba731d8f7ee675191a542b80a0ea3af951b15
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00632.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00632")
+public class BenchmarkTest00632 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00632");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00633.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00633.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d388a6afd9ec164c907666b3e66f32f44db7522
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00633.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00633")
+public class BenchmarkTest00633 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00633");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00634.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00634.java
new file mode 100644
index 0000000000000000000000000000000000000000..ffec5bbf5b8ba1ca75bac59ab5772177e45ed1b2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00634.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00634")
+public class BenchmarkTest00634 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00634");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00635.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00635.java
new file mode 100644
index 0000000000000000000000000000000000000000..360322bbf8c9b3a887baff9c8a39569611b07a2e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00635.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00635")
+public class BenchmarkTest00635 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00635");
+        if (param == null) param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00636.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00636.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f007cff2bf518631e9a08824a7362caadfe70c6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00636.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00636")
+public class BenchmarkTest00636 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00636");
+        if (param == null) param = "";
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00637.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00637.java
new file mode 100644
index 0000000000000000000000000000000000000000..c33ce7d7dcd2556cdb781a449a2b921a6645713c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00637.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00637")
+public class BenchmarkTest00637 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00637");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00638.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00638.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e56f11efc33b8dcc0aad3bf01383e99b498f761
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00638.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00638")
+public class BenchmarkTest00638 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00638");
+        if (param == null) param = "";
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00639.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00639.java
new file mode 100644
index 0000000000000000000000000000000000000000..b97eba22b4f6b1d02f07576b6c60cb188a09834b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00639.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00639")
+public class BenchmarkTest00639 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00639");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00640.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00640.java
new file mode 100644
index 0000000000000000000000000000000000000000..b23a8f1b88ce0bfe33bec106108937508b1785f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00640.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00640")
+public class BenchmarkTest00640 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00640");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00641.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00641.java
new file mode 100644
index 0000000000000000000000000000000000000000..b06099ba7f78caa5f89e7f046e54b4add4460e1b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00641.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00641")
+public class BenchmarkTest00641 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00641");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00642.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00642.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fa3a590f9addad37d8aa36c815ad0375fd791b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00642.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00642")
+public class BenchmarkTest00642 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00642");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00643.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00643.java
new file mode 100644
index 0000000000000000000000000000000000000000..fcee78612d401f1f26631f74699b1cccad41e040
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00643.java	
@@ -0,0 +1,36 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00643")
+public class BenchmarkTest00643 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00643");
+        if (param == null) param = "";
+
+        StringBuilder sbxyz31207 = new StringBuilder(param);
+        String bar = sbxyz31207.append("_SafeStuff").toString();
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00644.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00644.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b53dbc3dfbb99f6c54e18d6ea6bacd8400c51f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00644.java	
@@ -0,0 +1,36 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00644")
+public class BenchmarkTest00644 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00644");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00645.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00645.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8fcd97dbb543329865536364e205d1eadb9ca3b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00645.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00645")
+public class BenchmarkTest00645 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00645");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00646.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00646.java
new file mode 100644
index 0000000000000000000000000000000000000000..9858a1a938556dbd203aa5eba01054ee5be6c2e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00646.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00646")
+public class BenchmarkTest00646 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00646");
+        if (param == null) param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00647.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00647.java
new file mode 100644
index 0000000000000000000000000000000000000000..89bd0ec7e05c020a7af7f405200c9bf45fb50966
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00647.java	
@@ -0,0 +1,35 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00647")
+public class BenchmarkTest00647 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00647");
+        if (param == null) param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00648.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00648.java
new file mode 100644
index 0000000000000000000000000000000000000000..e0a478cc8d8c13bf445eae6edc99c73af94152bc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00648.java	
@@ -0,0 +1,35 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00648")
+public class BenchmarkTest00648 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00648");
+        if (param == null) param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00649.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00649.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3f765e8f203a57caa0c0938c5055829c07f2575
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00649.java	
@@ -0,0 +1,35 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00649")
+public class BenchmarkTest00649 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00649");
+        if (param == null) param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00650.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00650.java
new file mode 100644
index 0000000000000000000000000000000000000000..b16900b51d84fdc0520fd9e16bd4904b290f837f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00650.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00650")
+public class BenchmarkTest00650 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00650");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a17321 = param; // assign
+        StringBuilder b17321 = new StringBuilder(a17321); // stick in stringbuilder
+        b17321.append(" SafeStuff"); // append some safe content
+        b17321.replace(
+                b17321.length() - "Chars".length(),
+                b17321.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map17321 = new java.util.HashMap<String, Object>();
+        map17321.put("key17321", b17321.toString()); // put in a collection
+        String c17321 = (String) map17321.get("key17321"); // get it back out
+        String d17321 = c17321.substring(0, c17321.length() - 1); // extract most of it
+        String e17321 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d17321.getBytes()))); // B64 encode and decode it
+        String f17321 = e17321.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g17321 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g17321); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00651.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00651.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e8317ae52999d76b9eede1cf72a6e2fdf8d0e4f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00651.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00651")
+public class BenchmarkTest00651 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00651");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00652.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00652.java
new file mode 100644
index 0000000000000000000000000000000000000000..09b569d0f3ba0d6ec712ffaac5c2d9f433ae9a7a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00652.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00652")
+public class BenchmarkTest00652 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00652");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00653.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00653.java
new file mode 100644
index 0000000000000000000000000000000000000000..505ed71d7368ef2df656c2913468b5b7988b491d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00653.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00653")
+public class BenchmarkTest00653 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00653");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00654.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00654.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b97db3709290edafb19645343660abf3a860ff2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00654.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00654")
+public class BenchmarkTest00654 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00654");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00655.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00655.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9ceefdb4997050f719b9a09b2f5bf6c31cfbcf6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00655.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00655")
+public class BenchmarkTest00655 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00655");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00656.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00656.java
new file mode 100644
index 0000000000000000000000000000000000000000..c985a90d2e250b8e3b093401683d94181a7144bd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00656.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00656")
+public class BenchmarkTest00656 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00656");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00657.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00657.java
new file mode 100644
index 0000000000000000000000000000000000000000..809ec7186ad5c854c58a5f0b599ab34e15998bdd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00657.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00657")
+public class BenchmarkTest00657 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00657");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map27260 = new java.util.HashMap<String, Object>();
+        map27260.put("keyA-27260", "a_Value"); // put some stuff in the collection
+        map27260.put("keyB-27260", param); // put it in a collection
+        map27260.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map27260.get("keyB-27260"); // get it back out
+        bar = (String) map27260.get("keyA-27260"); // get safe value back out
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00658.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00658.java
new file mode 100644
index 0000000000000000000000000000000000000000..21cb3d24033c53e96742ad17d4fca17720d60135
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00658.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00658")
+public class BenchmarkTest00658 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00658");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00659.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00659.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4a8498ae44b83ce0eef9b8bbb3227486b5b5b41
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00659.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00659")
+public class BenchmarkTest00659 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00659");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00660.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00660.java
new file mode 100644
index 0000000000000000000000000000000000000000..00635699a6730128d2d719c603551ba5a7f0055e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00660.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00660")
+public class BenchmarkTest00660 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00660");
+        if (param == null) param = "";
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00661.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00661.java
new file mode 100644
index 0000000000000000000000000000000000000000..6aad855821c87ba3b8daeb201f8233a10a63f801
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00661.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00661")
+public class BenchmarkTest00661 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00661");
+        if (param == null) param = "";
+
+        String bar = param;
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00662.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00662.java
new file mode 100644
index 0000000000000000000000000000000000000000..e31f9b7707b53ec27940ea04780f9135cda85e4f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00662.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00662")
+public class BenchmarkTest00662 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00662");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00663.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00663.java
new file mode 100644
index 0000000000000000000000000000000000000000..27b71d19765115c6812bc83f993e546830e567c8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00663.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00663")
+public class BenchmarkTest00663 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00663");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map67527 = new java.util.HashMap<String, Object>();
+        map67527.put("keyA-67527", "a-Value"); // put some stuff in the collection
+        map67527.put("keyB-67527", param); // put it in a collection
+        map67527.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map67527.get("keyB-67527"); // get it back out
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00664.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00664.java
new file mode 100644
index 0000000000000000000000000000000000000000..df7785b436fd9199410b0a8f3c10d73edd477cdb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00664.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00664")
+public class BenchmarkTest00664 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00664");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a87833 = param; // assign
+        StringBuilder b87833 = new StringBuilder(a87833); // stick in stringbuilder
+        b87833.append(" SafeStuff"); // append some safe content
+        b87833.replace(
+                b87833.length() - "Chars".length(),
+                b87833.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map87833 = new java.util.HashMap<String, Object>();
+        map87833.put("key87833", b87833.toString()); // put in a collection
+        String c87833 = (String) map87833.get("key87833"); // get it back out
+        String d87833 = c87833.substring(0, c87833.length() - 1); // extract most of it
+        String e87833 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d87833.getBytes()))); // B64 encode and decode it
+        String f87833 = e87833.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g87833 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g87833); // reflection
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00665.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00665.java
new file mode 100644
index 0000000000000000000000000000000000000000..c91bfe92bb2f1060ee45b901725e07c23aff6814
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00665.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00665")
+public class BenchmarkTest00665 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00665");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00666.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00666.java
new file mode 100644
index 0000000000000000000000000000000000000000..4743ecf0b84f1a263b5f80012fcfc0350e1a8036
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00666.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00666")
+public class BenchmarkTest00666 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00666");
+        if (param == null) param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz65591 = new StringBuilder(param);
+            bar = sbxyz65591.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00667.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00667.java
new file mode 100644
index 0000000000000000000000000000000000000000..f755ee24981e30db195bcd193052ace676160fd5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00667.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00667")
+public class BenchmarkTest00667 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00667");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00668.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00668.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5d75561ee8369a0d4d74596d8dafb3f52e3939f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00668.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00668")
+public class BenchmarkTest00668 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00668");
+        if (param == null) param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00669.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00669.java
new file mode 100644
index 0000000000000000000000000000000000000000..aab7c757f037bc67c7c194f5a395802fcc7eb15f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00669.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00669")
+public class BenchmarkTest00669 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00669");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00670.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00670.java
new file mode 100644
index 0000000000000000000000000000000000000000..6298d0f9ae7f16830c0b829d2ca0dbabe76f30d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00670.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00670")
+public class BenchmarkTest00670 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00670");
+        if (param == null) param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz42704 = new StringBuilder(param);
+            bar = sbxyz42704.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00671.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00671.java
new file mode 100644
index 0000000000000000000000000000000000000000..d40de3a9154cb09c32cc770f1860c25a43a52603
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00671.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00671")
+public class BenchmarkTest00671 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00671");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00672.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00672.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f0efdb4dfe19a0b78241027abb193c9c1337799
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00672.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00672")
+public class BenchmarkTest00672 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00672");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00673.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00673.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fff64131cd1677b93d75c9e99fff2c134aea9fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00673.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00673")
+public class BenchmarkTest00673 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00673");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00674.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00674.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fa1b0e580d5dfee80fccf064ef21ae17136a6e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00674.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00674")
+public class BenchmarkTest00674 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00674");
+        if (param == null) param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a55926 = param; // assign
+        StringBuilder b55926 = new StringBuilder(a55926); // stick in stringbuilder
+        b55926.append(" SafeStuff"); // append some safe content
+        b55926.replace(
+                b55926.length() - "Chars".length(),
+                b55926.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map55926 = new java.util.HashMap<String, Object>();
+        map55926.put("key55926", b55926.toString()); // put in a collection
+        String c55926 = (String) map55926.get("key55926"); // get it back out
+        String d55926 = c55926.substring(0, c55926.length() - 1); // extract most of it
+        String e55926 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d55926.getBytes()))); // B64 encode and decode it
+        String f55926 = e55926.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g55926 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g55926); // reflection
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00675.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00675.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b8baca1fa636bd1bf7f7b81a7da02c04426b559
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00675.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00675")
+public class BenchmarkTest00675 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00675");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00676.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00676.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a6af34248d1f651266c9663cf29fcb0add2194d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00676.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00676")
+public class BenchmarkTest00676 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00676");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00677.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00677.java
new file mode 100644
index 0000000000000000000000000000000000000000..bcbe0584bcf05a0cbc1b0878fa0d8a0ff3b5db06
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00677.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00677")
+public class BenchmarkTest00677 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00677");
+        if (param == null) param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00678.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00678.java
new file mode 100644
index 0000000000000000000000000000000000000000..a247bd668c807afc535c94de25b3d893936b88d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00678.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00678")
+public class BenchmarkTest00678 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00678");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00679.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00679.java
new file mode 100644
index 0000000000000000000000000000000000000000..af5936f47b5d558cbe03aa4eebaaaf98fb6a19af
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00679.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00679")
+public class BenchmarkTest00679 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00679");
+        if (param == null) param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00680.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00680.java
new file mode 100644
index 0000000000000000000000000000000000000000..75723acc4e4470723e928bb7c7d4946ba044ab67
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00680.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00680")
+public class BenchmarkTest00680 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00680");
+        if (param == null) param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map33558 = new java.util.HashMap<String, Object>();
+        map33558.put("keyA-33558", "a_Value"); // put some stuff in the collection
+        map33558.put("keyB-33558", param); // put it in a collection
+        map33558.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map33558.get("keyB-33558"); // get it back out
+        bar = (String) map33558.get("keyA-33558"); // get safe value back out
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00681.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00681.java
new file mode 100644
index 0000000000000000000000000000000000000000..a6669de4927359453817741e8674867710dfe9ff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00681.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00681")
+public class BenchmarkTest00681 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00681");
+        if (param == null) param = "";
+
+        String bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00682.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00682.java
new file mode 100644
index 0000000000000000000000000000000000000000..065ed67e34f79d36dfdd22ab063242a5b082d339
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00682.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00682")
+public class BenchmarkTest00682 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00682");
+        if (param == null) param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00683.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00683.java
new file mode 100644
index 0000000000000000000000000000000000000000..49949436445b12c57060288668540e24591584f3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00683.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00683")
+public class BenchmarkTest00683 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest00683");
+        if (param == null) param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00684.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00684.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc574c77e67c0589c66daec2ff9840a40be1b7fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00684.java	
@@ -0,0 +1,132 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00684")
+public class BenchmarkTest00684 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00684");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00685.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00685.java
new file mode 100644
index 0000000000000000000000000000000000000000..512cb64dfa37a910d9674ef692e83c0a06df2606
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00685.java	
@@ -0,0 +1,136 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00685")
+public class BenchmarkTest00685 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00685");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz40853 = new StringBuilder(param);
+            bar = sbxyz40853.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00686.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00686.java
new file mode 100644
index 0000000000000000000000000000000000000000..47e96ca1d7e2cf7ab249d9ce846ff5e4d16919a4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00686.java	
@@ -0,0 +1,140 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00686")
+public class BenchmarkTest00686 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00686");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00687.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00687.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e5365b156b95e53edfdf17a128a69f89c465531
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00687.java	
@@ -0,0 +1,138 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00687")
+public class BenchmarkTest00687 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00687");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00688.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00688.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7f177a1b97790e6c39f934a27b771ac3fec827a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00688.java	
@@ -0,0 +1,143 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00688")
+public class BenchmarkTest00688 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00688");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00689.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00689.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f26d860b509f253cd131459390efcf0b42d192e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00689.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00689")
+public class BenchmarkTest00689 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00689");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a98281 = param; // assign
+        StringBuilder b98281 = new StringBuilder(a98281); // stick in stringbuilder
+        b98281.append(" SafeStuff"); // append some safe content
+        b98281.replace(
+                b98281.length() - "Chars".length(),
+                b98281.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map98281 = new java.util.HashMap<String, Object>();
+        map98281.put("key98281", b98281.toString()); // put in a collection
+        String c98281 = (String) map98281.get("key98281"); // get it back out
+        String d98281 = c98281.substring(0, c98281.length() - 1); // extract most of it
+        String e98281 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d98281.getBytes()))); // B64 encode and decode it
+        String f98281 = e98281.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g98281 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g98281); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00690.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00690.java
new file mode 100644
index 0000000000000000000000000000000000000000..21e3a66b5ccc0552734ff6611aaf487824afdb16
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00690.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00690")
+public class BenchmarkTest00690 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00690");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00691.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00691.java
new file mode 100644
index 0000000000000000000000000000000000000000..b452346c0e2769d93e80da233d439612948de7c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00691.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-00/BenchmarkTest00691")
+public class BenchmarkTest00691 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00691");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00692.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00692.java
new file mode 100644
index 0000000000000000000000000000000000000000..e35bb3c0c04e4a8dfd4af7a11f7ea9aa3ffeea90
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00692.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00692")
+public class BenchmarkTest00692 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00692");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00693.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00693.java
new file mode 100644
index 0000000000000000000000000000000000000000..cacccb3cb4f6c25ae0828d93eb1057e727e93073
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00693.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00693")
+public class BenchmarkTest00693 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00693");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00694.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00694.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9baac60e35db7c6c2c567c27601f4235ac04bb7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00694.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00694")
+public class BenchmarkTest00694 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00694");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00695.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00695.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed32aba79fb8dee85d5296d4e7bc31f904979143
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00695.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00695")
+public class BenchmarkTest00695 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00695");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map9400 = new java.util.HashMap<String, Object>();
+        map9400.put("keyA-9400", "a-Value"); // put some stuff in the collection
+        map9400.put("keyB-9400", param); // put it in a collection
+        map9400.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map9400.get("keyB-9400"); // get it back out
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00696.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00696.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2ea5c065ee6d40d5b40c698c0061995138a09d8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00696.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00696")
+public class BenchmarkTest00696 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00696");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00697.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00697.java
new file mode 100644
index 0000000000000000000000000000000000000000..a0cc416d2d12a1f26a6d2582db8c7fa63e12193c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00697.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00697")
+public class BenchmarkTest00697 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00697");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00698.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00698.java
new file mode 100644
index 0000000000000000000000000000000000000000..937535be5c67630053d03c67d435a75483536192
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00698.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00698")
+public class BenchmarkTest00698 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00698");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00699.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00699.java
new file mode 100644
index 0000000000000000000000000000000000000000..2379279617e2ec7fe5a42d23e986888c6ca51699
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00699.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00699")
+public class BenchmarkTest00699 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00699");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00700.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00700.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8fa768a128107af93f9c743e54eb111a51a34bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00700.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00700")
+public class BenchmarkTest00700 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00700");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00701.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00701.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f7c2612ec9816fa19f64db53b27ed5b135548b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00701.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00701")
+public class BenchmarkTest00701 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00701");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a85232 = param; // assign
+        StringBuilder b85232 = new StringBuilder(a85232); // stick in stringbuilder
+        b85232.append(" SafeStuff"); // append some safe content
+        b85232.replace(
+                b85232.length() - "Chars".length(),
+                b85232.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map85232 = new java.util.HashMap<String, Object>();
+        map85232.put("key85232", b85232.toString()); // put in a collection
+        String c85232 = (String) map85232.get("key85232"); // get it back out
+        String d85232 = c85232.substring(0, c85232.length() - 1); // extract most of it
+        String e85232 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d85232.getBytes()))); // B64 encode and decode it
+        String f85232 = e85232.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g85232 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g85232); // reflection
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00702.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00702.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9997886e90b0cb7f6ca158055372da84d7c0a84
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00702.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00702")
+public class BenchmarkTest00702 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00702");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00703.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00703.java
new file mode 100644
index 0000000000000000000000000000000000000000..683c3627ab0823fb34755b923f874713b7896e8f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00703.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00703")
+public class BenchmarkTest00703 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00703");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00704.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00704.java
new file mode 100644
index 0000000000000000000000000000000000000000..5fb2805203aafdd142fd396fa8da300bb60d26a3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00704.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00704")
+public class BenchmarkTest00704 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00704");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00705.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00705.java
new file mode 100644
index 0000000000000000000000000000000000000000..583931267015781e6ae7e93b21203061831fcb3b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00705.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00705")
+public class BenchmarkTest00705 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00705");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map71551 = new java.util.HashMap<String, Object>();
+        map71551.put("keyA-71551", "a_Value"); // put some stuff in the collection
+        map71551.put("keyB-71551", param); // put it in a collection
+        map71551.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map71551.get("keyB-71551"); // get it back out
+        bar = (String) map71551.get("keyA-71551"); // get safe value back out
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00706.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00706.java
new file mode 100644
index 0000000000000000000000000000000000000000..5711e36b42b85eb60d6a21c87623664e2b8a727c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00706.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00706")
+public class BenchmarkTest00706 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00706");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00707.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00707.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b1150f138565d9e8c52f5faa63d8df1fd4c5316
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00707.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00707")
+public class BenchmarkTest00707 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00707");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00708.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00708.java
new file mode 100644
index 0000000000000000000000000000000000000000..15e7610bee492ceedc977463558c37fe9da33c51
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00708.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00708")
+public class BenchmarkTest00708 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00708");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00709.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00709.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2451171a6f8bfa8b1a1f4c96054987afdf209fe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00709.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00709")
+public class BenchmarkTest00709 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00709");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00710.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00710.java
new file mode 100644
index 0000000000000000000000000000000000000000..ebf16fe4f2c7850d89511e79dd8b9cb359dc973f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00710.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00710")
+public class BenchmarkTest00710 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00710");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00711.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00711.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac5a71718dda3c9cad54494de707b0fd470f6112
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00711.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00711")
+public class BenchmarkTest00711 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00711");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00712.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00712.java
new file mode 100644
index 0000000000000000000000000000000000000000..7462e971c1e45a5f5f6d375ea19f84d91c9d44ba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00712.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00712")
+public class BenchmarkTest00712 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00712");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00713.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00713.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b46de4979f677b8af86a437231814f617d129aa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00713.java	
@@ -0,0 +1,36 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00713")
+public class BenchmarkTest00713 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00713");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00714.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00714.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ac4d2a4159f1ce1d250543989747c3f0813921a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00714.java	
@@ -0,0 +1,36 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00714")
+public class BenchmarkTest00714 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00714");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00715.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00715.java
new file mode 100644
index 0000000000000000000000000000000000000000..09824e36ab8f39f54c93b631114bba4c05c314ce
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00715.java	
@@ -0,0 +1,36 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00715")
+public class BenchmarkTest00715 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00715");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00716.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00716.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ea78e65d8df0250f51b52db9a933551e08c5725
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00716.java	
@@ -0,0 +1,36 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00716")
+public class BenchmarkTest00716 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00716");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00717.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00717.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ceabf6f69eb3c3007deb110ea2faff69bfad50a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00717.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00717")
+public class BenchmarkTest00717 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00717");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a59129 = param; // assign
+        StringBuilder b59129 = new StringBuilder(a59129); // stick in stringbuilder
+        b59129.append(" SafeStuff"); // append some safe content
+        b59129.replace(
+                b59129.length() - "Chars".length(),
+                b59129.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map59129 = new java.util.HashMap<String, Object>();
+        map59129.put("key59129", b59129.toString()); // put in a collection
+        String c59129 = (String) map59129.get("key59129"); // get it back out
+        String d59129 = c59129.substring(0, c59129.length() - 1); // extract most of it
+        String e59129 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d59129.getBytes()))); // B64 encode and decode it
+        String f59129 = e59129.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g59129 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g59129); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00718.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00718.java
new file mode 100644
index 0000000000000000000000000000000000000000..152aa9c3a0fd38d435fdae094f2288f87f0a75a3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00718.java	
@@ -0,0 +1,36 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00718")
+public class BenchmarkTest00718 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00718");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00719.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00719.java
new file mode 100644
index 0000000000000000000000000000000000000000..1047169d7aec86bff079535472b99ca3245c61bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00719.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00719")
+public class BenchmarkTest00719 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00719");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00720.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00720.java
new file mode 100644
index 0000000000000000000000000000000000000000..de6fc03b3ea61f8298ccb4171b7852d32486dbbb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00720.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00720")
+public class BenchmarkTest00720 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00720");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00721.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00721.java
new file mode 100644
index 0000000000000000000000000000000000000000..404adf52954ff0e8fa8e032d93a6a804c229056d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00721.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00721")
+public class BenchmarkTest00721 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00721");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00722.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00722.java
new file mode 100644
index 0000000000000000000000000000000000000000..b4ca5459278db12f1051349a2c190517c5e60b59
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00722.java	
@@ -0,0 +1,42 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00722")
+public class BenchmarkTest00722 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00722");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map49442 = new java.util.HashMap<String, Object>();
+        map49442.put("keyA-49442", "a_Value"); // put some stuff in the collection
+        map49442.put("keyB-49442", param); // put it in a collection
+        map49442.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map49442.get("keyB-49442"); // get it back out
+        bar = (String) map49442.get("keyA-49442"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00723.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00723.java
new file mode 100644
index 0000000000000000000000000000000000000000..23eac63b044ade9e0b24bb5f947d8942cd218fae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00723.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00723")
+public class BenchmarkTest00723 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00723");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00724.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00724.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c8b71931700c87470214b46f28cd25a3c9deab2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00724.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00724")
+public class BenchmarkTest00724 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00724");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00725.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00725.java
new file mode 100644
index 0000000000000000000000000000000000000000..7abf6983db60663c77fbd1ef82c7567935e6ec52
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00725.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00725")
+public class BenchmarkTest00725 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00725");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a49441 = param; // assign
+        StringBuilder b49441 = new StringBuilder(a49441); // stick in stringbuilder
+        b49441.append(" SafeStuff"); // append some safe content
+        b49441.replace(
+                b49441.length() - "Chars".length(),
+                b49441.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map49441 = new java.util.HashMap<String, Object>();
+        map49441.put("key49441", b49441.toString()); // put in a collection
+        String c49441 = (String) map49441.get("key49441"); // get it back out
+        String d49441 = c49441.substring(0, c49441.length() - 1); // extract most of it
+        String e49441 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d49441.getBytes()))); // B64 encode and decode it
+        String f49441 = e49441.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f49441); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00726.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00726.java
new file mode 100644
index 0000000000000000000000000000000000000000..97d1886ef50de15d271ee1ab041ff2a36e08337e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00726.java	
@@ -0,0 +1,35 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00726")
+public class BenchmarkTest00726 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00726");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00727.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00727.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ec13133a641f1f48b7bec12561429865a3f2181
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00727.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00727")
+public class BenchmarkTest00727 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00727");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00728.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00728.java
new file mode 100644
index 0000000000000000000000000000000000000000..b7efad5e595fd78a200f9d3576a737e90778a76f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00728.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00728")
+public class BenchmarkTest00728 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00728");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00729.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00729.java
new file mode 100644
index 0000000000000000000000000000000000000000..019fe4c717f18bb8efef2cd7b8090a6190c6afd0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00729.java	
@@ -0,0 +1,37 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00729")
+public class BenchmarkTest00729 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00729");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00730.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00730.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4088698b5a5b88b39b1e2a07ca974baf451f890
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00730.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00730")
+public class BenchmarkTest00730 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00730");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map29173 = new java.util.HashMap<String, Object>();
+        map29173.put("keyA-29173", "a_Value"); // put some stuff in the collection
+        map29173.put("keyB-29173", param); // put it in a collection
+        map29173.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map29173.get("keyB-29173"); // get it back out
+        bar = (String) map29173.get("keyA-29173"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00731.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00731.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c93c48f24b21fa35f080d40e58c88376b602395
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00731.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00731")
+public class BenchmarkTest00731 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00731");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00732.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00732.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3de43da06016d825d0bbbaffc44c2fa642c14e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00732.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00732")
+public class BenchmarkTest00732 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00732");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map99333 = new java.util.HashMap<String, Object>();
+        map99333.put("keyA-99333", "a_Value"); // put some stuff in the collection
+        map99333.put("keyB-99333", param); // put it in a collection
+        map99333.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map99333.get("keyB-99333"); // get it back out
+        bar = (String) map99333.get("keyA-99333"); // get safe value back out
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00733.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00733.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2907bf528909267310b85e0ea9fe6637fb8bac1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00733.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00733")
+public class BenchmarkTest00733 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00733");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        StringBuilder sbxyz15959 = new StringBuilder(param);
+        String bar = sbxyz15959.append("_SafeStuff").toString();
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00734.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00734.java
new file mode 100644
index 0000000000000000000000000000000000000000..169b68c062e0de9dbebf1bdcab723fe2ec4ee74d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00734.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00734")
+public class BenchmarkTest00734 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00734");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00735.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00735.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5cac287c17ee4e92993c10046b57bec38421a9a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00735.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00735")
+public class BenchmarkTest00735 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00735");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00736.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00736.java
new file mode 100644
index 0000000000000000000000000000000000000000..24b4d234c749128cf2a56d245c6e217915e01bd9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00736.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00736")
+public class BenchmarkTest00736 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00736");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00737.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00737.java
new file mode 100644
index 0000000000000000000000000000000000000000..369cf56b8974fdffff6f611873685d5d0de2e160
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00737.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00737")
+public class BenchmarkTest00737 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00737");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a57334 = param; // assign
+        StringBuilder b57334 = new StringBuilder(a57334); // stick in stringbuilder
+        b57334.append(" SafeStuff"); // append some safe content
+        b57334.replace(
+                b57334.length() - "Chars".length(),
+                b57334.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map57334 = new java.util.HashMap<String, Object>();
+        map57334.put("key57334", b57334.toString()); // put in a collection
+        String c57334 = (String) map57334.get("key57334"); // get it back out
+        String d57334 = c57334.substring(0, c57334.length() - 1); // extract most of it
+        String e57334 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d57334.getBytes()))); // B64 encode and decode it
+        String f57334 = e57334.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f57334); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00738.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00738.java
new file mode 100644
index 0000000000000000000000000000000000000000..79a54003fc92d982fafe0059ec4ca53442dbd36e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00738.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00738")
+public class BenchmarkTest00738 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00738");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00739.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00739.java
new file mode 100644
index 0000000000000000000000000000000000000000..700da2eaacf611e299a2757ee0681f097e6f357e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00739.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00739")
+public class BenchmarkTest00739 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00739");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00740.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00740.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8b5a6abf773dd1a7d5c7b8a2c28e9c41db4ec0a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00740.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00740")
+public class BenchmarkTest00740 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00740");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map87432 = new java.util.HashMap<String, Object>();
+        map87432.put("keyA-87432", "a-Value"); // put some stuff in the collection
+        map87432.put("keyB-87432", param); // put it in a collection
+        map87432.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map87432.get("keyB-87432"); // get it back out
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00741.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00741.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ee89c9d5f914475d110b9678aa7c80c5db14c6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00741.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00741")
+public class BenchmarkTest00741 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00741");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00742.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00742.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2a3129377bfcdce94887d3bdce1e0ab06717bb4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00742.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00742")
+public class BenchmarkTest00742 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00742");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map62435 = new java.util.HashMap<String, Object>();
+        map62435.put("keyA-62435", "a_Value"); // put some stuff in the collection
+        map62435.put("keyB-62435", param); // put it in a collection
+        map62435.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map62435.get("keyB-62435"); // get it back out
+        bar = (String) map62435.get("keyA-62435"); // get safe value back out
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00743.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00743.java
new file mode 100644
index 0000000000000000000000000000000000000000..d944b9749e5ef60cde2004c64e664f6086a82350
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00743.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00743")
+public class BenchmarkTest00743 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00743");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00744.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00744.java
new file mode 100644
index 0000000000000000000000000000000000000000..580ade79e9e59ce9ab406833dabd310a6c67a342
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00744.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00744")
+public class BenchmarkTest00744 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00744");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00745.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00745.java
new file mode 100644
index 0000000000000000000000000000000000000000..927629b24636dff7edcef02754956177348029f9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00745.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00745")
+public class BenchmarkTest00745 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00745");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00746.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00746.java
new file mode 100644
index 0000000000000000000000000000000000000000..163886513ed5f6503175580e8b9e2e79e7453b8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00746.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00746")
+public class BenchmarkTest00746 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00746");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00747.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00747.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fb7ebd782def09968438259ec8ab9f204d3e1a6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00747.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00747")
+public class BenchmarkTest00747 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00747");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00748.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00748.java
new file mode 100644
index 0000000000000000000000000000000000000000..e246da94498bcc790b76ad065fa69d5c25698156
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00748.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00748")
+public class BenchmarkTest00748 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00748");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        // Chain a bunch of propagators in sequence
+        String a43085 = param; // assign
+        StringBuilder b43085 = new StringBuilder(a43085); // stick in stringbuilder
+        b43085.append(" SafeStuff"); // append some safe content
+        b43085.replace(
+                b43085.length() - "Chars".length(),
+                b43085.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map43085 = new java.util.HashMap<String, Object>();
+        map43085.put("key43085", b43085.toString()); // put in a collection
+        String c43085 = (String) map43085.get("key43085"); // get it back out
+        String d43085 = c43085.substring(0, c43085.length() - 1); // extract most of it
+        String e43085 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d43085.getBytes()))); // B64 encode and decode it
+        String f43085 = e43085.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g43085 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g43085); // reflection
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00749.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00749.java
new file mode 100644
index 0000000000000000000000000000000000000000..c48e176987894bad50e2974b60432e747195ecf4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00749.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00749")
+public class BenchmarkTest00749 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00749");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        StringBuilder sbxyz94097 = new StringBuilder(param);
+        String bar = sbxyz94097.append("_SafeStuff").toString();
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00750.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00750.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1186649b8e85e0d2c0b1fe18cbda417b052f6c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00750.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00750")
+public class BenchmarkTest00750 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00750");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz18731 = new StringBuilder(param);
+            bar = sbxyz18731.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00751.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00751.java
new file mode 100644
index 0000000000000000000000000000000000000000..fcd3b7854e6c192eb7b0e6ad4afceb9e09250087
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00751.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00751")
+public class BenchmarkTest00751 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00751");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00752.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00752.java
new file mode 100644
index 0000000000000000000000000000000000000000..efc6a49751ceb7fd3123e6e6a29e138ec1db217b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00752.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00752")
+public class BenchmarkTest00752 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00752");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00753.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00753.java
new file mode 100644
index 0000000000000000000000000000000000000000..974a28582106d5a2bbcaeb0e9ba12e5aa7e32ef7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00753.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00753")
+public class BenchmarkTest00753 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00753");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00754.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00754.java
new file mode 100644
index 0000000000000000000000000000000000000000..226c5c897b2d3fa6fb73e236769e1c1304d65f15
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00754.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00754")
+public class BenchmarkTest00754 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00754");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map6425 = new java.util.HashMap<String, Object>();
+        map6425.put("keyA-6425", "a-Value"); // put some stuff in the collection
+        map6425.put("keyB-6425", param); // put it in a collection
+        map6425.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map6425.get("keyB-6425"); // get it back out
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00755.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00755.java
new file mode 100644
index 0000000000000000000000000000000000000000..dda53efb718b80fdeb435d5edc738c5aaf833603
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00755.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00755")
+public class BenchmarkTest00755 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00755");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00756.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00756.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f9ab9e82dc0507290084c4117cd5cbc5fa169f8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00756.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00756")
+public class BenchmarkTest00756 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00756");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00757.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00757.java
new file mode 100644
index 0000000000000000000000000000000000000000..9303ae49b14dc48a82d6921ad5a577a481eb0312
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00757.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00757")
+public class BenchmarkTest00757 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00757");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00758.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00758.java
new file mode 100644
index 0000000000000000000000000000000000000000..e835615408719a937e7ba79421b2e16ed0d7f089
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00758.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00758")
+public class BenchmarkTest00758 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00758");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00759.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00759.java
new file mode 100644
index 0000000000000000000000000000000000000000..ddfe5336165770e8eac6d03aceba0a3d75f36522
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00759.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00759")
+public class BenchmarkTest00759 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00759");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00760.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00760.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ce7d9c1410d76bc8d6904a899ca5ba1b30e1ab2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00760.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00760")
+public class BenchmarkTest00760 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00760");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map18915 = new java.util.HashMap<String, Object>();
+        map18915.put("keyA-18915", "a-Value"); // put some stuff in the collection
+        map18915.put("keyB-18915", param); // put it in a collection
+        map18915.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map18915.get("keyB-18915"); // get it back out
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00761.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00761.java
new file mode 100644
index 0000000000000000000000000000000000000000..1576a185fd15d32d167f5a2abb2be1061995e355
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00761.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00761")
+public class BenchmarkTest00761 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00761");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00762.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00762.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf0c01c82ebc6bc965b38b0cb3601cef747efc3f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00762.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00762")
+public class BenchmarkTest00762 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00762");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00763.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00763.java
new file mode 100644
index 0000000000000000000000000000000000000000..7107f9a018424c904761d625f0e260efca3a3b03
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00763.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00763")
+public class BenchmarkTest00763 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00763");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00764.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00764.java
new file mode 100644
index 0000000000000000000000000000000000000000..e990c8f0fd6fd9bd0af90c5a33ce6e6ccabe2cf9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00764.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00764")
+public class BenchmarkTest00764 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00764");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = param;
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00765.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00765.java
new file mode 100644
index 0000000000000000000000000000000000000000..2592efbbdd24f877dd584775f63e9b7d46327317
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00765.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00765")
+public class BenchmarkTest00765 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00765");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00766.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00766.java
new file mode 100644
index 0000000000000000000000000000000000000000..f53307379c8c97af767982f95c88efa506223419
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00766.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00766")
+public class BenchmarkTest00766 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00766");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00767.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00767.java
new file mode 100644
index 0000000000000000000000000000000000000000..7789e883f89a41c90b22ad204204b9822bea5123
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00767.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00767")
+public class BenchmarkTest00767 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00767");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00768.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00768.java
new file mode 100644
index 0000000000000000000000000000000000000000..0cad9946567e3ce15265e5ab086a6113e9327ddf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00768.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00768")
+public class BenchmarkTest00768 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00768");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00769.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00769.java
new file mode 100644
index 0000000000000000000000000000000000000000..c795de0b15f19d13d61a827666a1143afda5b48b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00769.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00769")
+public class BenchmarkTest00769 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00769");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map29572 = new java.util.HashMap<String, Object>();
+        map29572.put("keyA-29572", "a-Value"); // put some stuff in the collection
+        map29572.put("keyB-29572", param); // put it in a collection
+        map29572.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map29572.get("keyB-29572"); // get it back out
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00770.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00770.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c7156cafe81a38f2e9c13dcf8bde6d689bd75bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00770.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00770")
+public class BenchmarkTest00770 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00770");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00771.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00771.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e802eae4d5be0a61180820f047355dfe1a27ba7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00771.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00771")
+public class BenchmarkTest00771 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00771");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map49960 = new java.util.HashMap<String, Object>();
+        map49960.put("keyA-49960", "a-Value"); // put some stuff in the collection
+        map49960.put("keyB-49960", param); // put it in a collection
+        map49960.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map49960.get("keyB-49960"); // get it back out
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00772.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00772.java
new file mode 100644
index 0000000000000000000000000000000000000000..766142a06d2a6657b2a8545d7f0c44f7e502a0b3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00772.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00772")
+public class BenchmarkTest00772 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00772");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00773.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00773.java
new file mode 100644
index 0000000000000000000000000000000000000000..96ff8abf994f4490b8f557e70f224546a5f723aa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00773.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00773")
+public class BenchmarkTest00773 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00773");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00774.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00774.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4031ab6f8a813786874197188103f112291ccaf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00774.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00774")
+public class BenchmarkTest00774 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest00774");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00775.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00775.java
new file mode 100644
index 0000000000000000000000000000000000000000..391e9eeadb0fc09f5190d1e4646a147e75fc66c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00775.java	
@@ -0,0 +1,165 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00775")
+public class BenchmarkTest00775 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00775" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00775"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00775" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00776.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00776.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b85935299795f0dddaae6c7ebbcc195c73875d3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00776.java	
@@ -0,0 +1,162 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00776")
+public class BenchmarkTest00776 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00776" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00776"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00776" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00777.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00777.java
new file mode 100644
index 0000000000000000000000000000000000000000..ebe0a742684e3fc609db8487169ef715e18f4af5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00777.java	
@@ -0,0 +1,161 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00777")
+public class BenchmarkTest00777 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00777" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00777"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00777" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map4544 = new java.util.HashMap<String, Object>();
+        map4544.put("keyA-4544", "a_Value"); // put some stuff in the collection
+        map4544.put("keyB-4544", param); // put it in a collection
+        map4544.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map4544.get("keyB-4544"); // get it back out
+        bar = (String) map4544.get("keyA-4544"); // get safe value back out
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00778.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00778.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c8e1c36558f5d6d04a1f395e22a3f75f724a687
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00778.java	
@@ -0,0 +1,160 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00778")
+public class BenchmarkTest00778 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00778" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00778"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00778" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00779.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00779.java
new file mode 100644
index 0000000000000000000000000000000000000000..33dffa31a4e7743cc081ec9c6530e4c7663ca822
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00779.java	
@@ -0,0 +1,158 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00779")
+public class BenchmarkTest00779 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00779" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00779"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00779" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00780.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00780.java
new file mode 100644
index 0000000000000000000000000000000000000000..350470685ddecefefb759cccedb2e0047165d7e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00780.java	
@@ -0,0 +1,133 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00780")
+public class BenchmarkTest00780 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00780" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00780"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00780" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00781.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00781.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1194886cdc8ef1b709bcf5fe49e8b66d5498a52
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00781.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00781")
+public class BenchmarkTest00781 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00781" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00781"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00781" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00782.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00782.java
new file mode 100644
index 0000000000000000000000000000000000000000..ddbc3e36aecd72ab1657d1d4712d714d1d8bc663
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00782.java	
@@ -0,0 +1,135 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00782")
+public class BenchmarkTest00782 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00782" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00782"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00782" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00783.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00783.java
new file mode 100644
index 0000000000000000000000000000000000000000..b094e243780e1734cc9af7a4a5e0466e2f4a7e48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00783.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00783")
+public class BenchmarkTest00783 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00783" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00783"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00783" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map2299 = new java.util.HashMap<String, Object>();
+        map2299.put("keyA-2299", "a-Value"); // put some stuff in the collection
+        map2299.put("keyB-2299", param); // put it in a collection
+        map2299.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map2299.get("keyB-2299"); // get it back out
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00784.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00784.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fc13585fdcb9b10d53d6d07490bd19b235e9096
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00784.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00784")
+public class BenchmarkTest00784 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00784" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00784"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00784" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00785.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00785.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c18d05784ff69b6bc41b3447a93034f0f619480
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00785.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00785")
+public class BenchmarkTest00785 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00785" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00785"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00785" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map59480 = new java.util.HashMap<String, Object>();
+        map59480.put("keyA-59480", "a-Value"); // put some stuff in the collection
+        map59480.put("keyB-59480", param); // put it in a collection
+        map59480.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map59480.get("keyB-59480"); // get it back out
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00786.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00786.java
new file mode 100644
index 0000000000000000000000000000000000000000..bac265392e79638fa2e60718341ff53f0129da94
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00786.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00786")
+public class BenchmarkTest00786 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00786" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00786"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00786" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map29957 = new java.util.HashMap<String, Object>();
+        map29957.put("keyA-29957", "a_Value"); // put some stuff in the collection
+        map29957.put("keyB-29957", param); // put it in a collection
+        map29957.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map29957.get("keyB-29957"); // get it back out
+        bar = (String) map29957.get("keyA-29957"); // get safe value back out
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00787.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00787.java
new file mode 100644
index 0000000000000000000000000000000000000000..41600ea74166873a32242dffdb3a5b9a9235394d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00787.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00787")
+public class BenchmarkTest00787 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00787" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00787"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00787" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00788.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00788.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc836e996ed0d35df95ca30d8707d60334741d5c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00788.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00788")
+public class BenchmarkTest00788 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00788" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00788"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00788" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00789.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00789.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad4586068ad76dea79f4ca5b8f644ba4a034879c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00789.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00789")
+public class BenchmarkTest00789 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00789" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00789"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00789" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00790.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00790.java
new file mode 100644
index 0000000000000000000000000000000000000000..60b571270384aecfef26ef1e428b77c6d228354e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00790.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00790")
+public class BenchmarkTest00790 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00790" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00790"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00790" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00791.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00791.java
new file mode 100644
index 0000000000000000000000000000000000000000..026a8c5fa9ce6dab9caf159dde246c60f2c6225e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00791.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00791")
+public class BenchmarkTest00791 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00791" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00791"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00791" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00792.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00792.java
new file mode 100644
index 0000000000000000000000000000000000000000..9898f4bdb8fef5ebb333d3b72ec435fe2ce8feea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00792.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00792")
+public class BenchmarkTest00792 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00792" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00792"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00792" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map53005 = new java.util.HashMap<String, Object>();
+        map53005.put("keyA-53005", "a_Value"); // put some stuff in the collection
+        map53005.put("keyB-53005", param); // put it in a collection
+        map53005.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map53005.get("keyB-53005"); // get it back out
+        bar = (String) map53005.get("keyA-53005"); // get safe value back out
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00793.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00793.java
new file mode 100644
index 0000000000000000000000000000000000000000..40b6d0b53e7c7c86a984dba022ef0703baf885cf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00793.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00793")
+public class BenchmarkTest00793 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00793" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00793"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00793" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00794.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00794.java
new file mode 100644
index 0000000000000000000000000000000000000000..608c5a27bc4265de1ebdaa345c9ef116d40e6369
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00794.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00794")
+public class BenchmarkTest00794 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00794" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00794"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00794" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00795.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00795.java
new file mode 100644
index 0000000000000000000000000000000000000000..47c743d1035c03ca591f0f60d1c18516bcf6ee62
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00795.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00795")
+public class BenchmarkTest00795 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00795" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00795"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00795" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00796.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00796.java
new file mode 100644
index 0000000000000000000000000000000000000000..cfa86365124f16129c5d40c69f1591bf4ce9d0da
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00796.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-00/BenchmarkTest00796")
+public class BenchmarkTest00796 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00796" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00796"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00796" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map72213 = new java.util.HashMap<String, Object>();
+        map72213.put("keyA-72213", "a-Value"); // put some stuff in the collection
+        map72213.put("keyB-72213", param); // put it in a collection
+        map72213.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map72213.get("keyB-72213"); // get it back out
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00797.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00797.java
new file mode 100644
index 0000000000000000000000000000000000000000..0639a25878ed163e7d31acb4e30cea2cd799c7a6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00797.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00797")
+public class BenchmarkTest00797 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00797" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00797"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00797" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz97281 = new StringBuilder(param);
+            bar = sbxyz97281.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00798.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00798.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d9bd06e032118d76c3c9314c920e9e97b293bea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00798.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00798")
+public class BenchmarkTest00798 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00798" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00798"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00798" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz25489 = new StringBuilder(param);
+            bar = sbxyz25489.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00799.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00799.java
new file mode 100644
index 0000000000000000000000000000000000000000..c40f24b4f5ba5454a5f82f32c6d0e14aa93d746d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00799.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00799")
+public class BenchmarkTest00799 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00799" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00799"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00799" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00800.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00800.java
new file mode 100644
index 0000000000000000000000000000000000000000..d941b0fcd42629a60bce82ee2204576b137f60db
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00800.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00800")
+public class BenchmarkTest00800 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00800" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00800"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00800" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00801.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00801.java
new file mode 100644
index 0000000000000000000000000000000000000000..a52b3d7a4fa6a7531376f6646b85b8806c34e41f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00801.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00801")
+public class BenchmarkTest00801 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00801" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00801"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00801" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00802.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00802.java
new file mode 100644
index 0000000000000000000000000000000000000000..150b0235e8b8cd23bb584fca1b8db5c94cca4659
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00802.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00802")
+public class BenchmarkTest00802 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00802" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00802"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00802" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00803.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00803.java
new file mode 100644
index 0000000000000000000000000000000000000000..09daa781c1fcd33c3a57ac4648eea39533ca9aca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00803.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00803")
+public class BenchmarkTest00803 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00803" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00803"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00803" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00804.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00804.java
new file mode 100644
index 0000000000000000000000000000000000000000..7618f053456fcd2f9b0e325f4f3ecc91fc298aba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00804.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00804")
+public class BenchmarkTest00804 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00804" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00804"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00804" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        StringBuilder sbxyz12823 = new StringBuilder(param);
+        String bar = sbxyz12823.append("_SafeStuff").toString();
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00805.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00805.java
new file mode 100644
index 0000000000000000000000000000000000000000..5255d85ae5b8787bb90d695db77287cc5819255f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00805.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00805")
+public class BenchmarkTest00805 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00805" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00805"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00805" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a72616 = param; // assign
+        StringBuilder b72616 = new StringBuilder(a72616); // stick in stringbuilder
+        b72616.append(" SafeStuff"); // append some safe content
+        b72616.replace(
+                b72616.length() - "Chars".length(),
+                b72616.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map72616 = new java.util.HashMap<String, Object>();
+        map72616.put("key72616", b72616.toString()); // put in a collection
+        String c72616 = (String) map72616.get("key72616"); // get it back out
+        String d72616 = c72616.substring(0, c72616.length() - 1); // extract most of it
+        String e72616 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d72616.getBytes()))); // B64 encode and decode it
+        String f72616 = e72616.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f72616); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00806.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00806.java
new file mode 100644
index 0000000000000000000000000000000000000000..55921713f99bfd79d9097fd2bd33d6506da64497
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00806.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00806")
+public class BenchmarkTest00806 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00806" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00806"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00806" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00807.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00807.java
new file mode 100644
index 0000000000000000000000000000000000000000..9dd01fd6839810ea1b7437c4d920e0d260ea8048
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00807.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00807")
+public class BenchmarkTest00807 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00807" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00807"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00807" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00808.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00808.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2fe266f09edf842ac327316bd36a86691935cef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00808.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00808")
+public class BenchmarkTest00808 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00808" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00808"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00808" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00809.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00809.java
new file mode 100644
index 0000000000000000000000000000000000000000..97d421f51a72195b6a17a9e330c8f1cfd0c7947f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00809.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00809")
+public class BenchmarkTest00809 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00809" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00809"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00809" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00810.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00810.java
new file mode 100644
index 0000000000000000000000000000000000000000..e560c03cbb9a6b973f06291d32bc8542d525156a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00810.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00810")
+public class BenchmarkTest00810 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00810" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00810"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00810" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        StringBuilder sbxyz36624 = new StringBuilder(param);
+        String bar = sbxyz36624.append("_SafeStuff").toString();
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00811.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00811.java
new file mode 100644
index 0000000000000000000000000000000000000000..83af27271d39ac2d981d210cdf71cd1625d031cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00811.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00811")
+public class BenchmarkTest00811 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00811" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00811"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00811" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00812.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00812.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb72619a0b2598f081ab3ba359feb6ddae532040
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00812.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00812")
+public class BenchmarkTest00812 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00812" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00812"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00812" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00813.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00813.java
new file mode 100644
index 0000000000000000000000000000000000000000..df7750cecfe88d0fc085fe163e70d7c9885d532e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00813.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00813")
+public class BenchmarkTest00813 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00813" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00813"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00813" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00814.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00814.java
new file mode 100644
index 0000000000000000000000000000000000000000..f441cf9a3651e4b5ea34d63516c21ef32c70a26a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00814.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00814")
+public class BenchmarkTest00814 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00814" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00814"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00814" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00815.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00815.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b650b21497e8532749f32124486deba26eecb28
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00815.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00815")
+public class BenchmarkTest00815 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00815" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00815"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00815" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00816.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00816.java
new file mode 100644
index 0000000000000000000000000000000000000000..8bcaf10a203ab6cb255c6a49f2ffc223f4d921d4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00816.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00816")
+public class BenchmarkTest00816 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00816" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00816"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00816" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map34260 = new java.util.HashMap<String, Object>();
+        map34260.put("keyA-34260", "a-Value"); // put some stuff in the collection
+        map34260.put("keyB-34260", param); // put it in a collection
+        map34260.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map34260.get("keyB-34260"); // get it back out
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00817.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00817.java
new file mode 100644
index 0000000000000000000000000000000000000000..60e45c79a2ec2ea8136a679eb0820d6e445b5c7e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00817.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00817")
+public class BenchmarkTest00817 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00817" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00817"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00817" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a9795 = param; // assign
+        StringBuilder b9795 = new StringBuilder(a9795); // stick in stringbuilder
+        b9795.append(" SafeStuff"); // append some safe content
+        b9795.replace(
+                b9795.length() - "Chars".length(),
+                b9795.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map9795 = new java.util.HashMap<String, Object>();
+        map9795.put("key9795", b9795.toString()); // put in a collection
+        String c9795 = (String) map9795.get("key9795"); // get it back out
+        String d9795 = c9795.substring(0, c9795.length() - 1); // extract most of it
+        String e9795 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d9795.getBytes()))); // B64 encode and decode it
+        String f9795 = e9795.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f9795); // reflection
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00818.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00818.java
new file mode 100644
index 0000000000000000000000000000000000000000..64510b109b562a37ee84851174300b8a6b36c317
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00818.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00818")
+public class BenchmarkTest00818 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00818" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00818"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00818" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00819.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00819.java
new file mode 100644
index 0000000000000000000000000000000000000000..98408a5f6c429cff984bb5f28550e17b6692ef2a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00819.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00819")
+public class BenchmarkTest00819 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00819" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00819"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00819" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00820.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00820.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d635bde7743b8213d4610ceb3dba69b8878736a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00820.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00820")
+public class BenchmarkTest00820 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00820" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00820"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00820" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00821.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00821.java
new file mode 100644
index 0000000000000000000000000000000000000000..1429899d4a87eb436e7c4c600ca0d9036b14ed18
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00821.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00821")
+public class BenchmarkTest00821 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00821" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00821"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00821" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00822.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00822.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6d11dffb92ca051a96d1f03a671cf4f0de1d23a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00822.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00822")
+public class BenchmarkTest00822 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00822" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00822"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00822" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00823.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00823.java
new file mode 100644
index 0000000000000000000000000000000000000000..d73f34441e1d703600169a530371840140026120
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00823.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00823")
+public class BenchmarkTest00823 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00823" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00823"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00823" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00824.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00824.java
new file mode 100644
index 0000000000000000000000000000000000000000..e704e596769b28e22493dae98a5cdf004959b1f3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00824.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00824")
+public class BenchmarkTest00824 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00824" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00824"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00824" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map57450 = new java.util.HashMap<String, Object>();
+        map57450.put("keyA-57450", "a-Value"); // put some stuff in the collection
+        map57450.put("keyB-57450", param); // put it in a collection
+        map57450.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map57450.get("keyB-57450"); // get it back out
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00825.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00825.java
new file mode 100644
index 0000000000000000000000000000000000000000..e937b595a7490a463072cfaa9ae4e4ace01e8f7c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00825.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00825")
+public class BenchmarkTest00825 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00825" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00825"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00825" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00826.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00826.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e9fe11b0dff4399b7e6cf4e514606f808858a73
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00826.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00826")
+public class BenchmarkTest00826 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00826" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00826"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00826" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00827.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00827.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5c919234aef07fc87949169ca5f6cc18d43c48d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00827.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-00/BenchmarkTest00827")
+public class BenchmarkTest00827 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00827" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00827"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00827" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00828.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00828.java
new file mode 100644
index 0000000000000000000000000000000000000000..cecab50635278b6ae0a693a030a83dcb610903d6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00828.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00828")
+public class BenchmarkTest00828 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00828" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00828"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00828" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00829.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00829.java
new file mode 100644
index 0000000000000000000000000000000000000000..1fce7233b6e4618a1c2b5ae2f159caea02234b7f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00829.java	
@@ -0,0 +1,136 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00829")
+public class BenchmarkTest00829 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00829" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00829"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00829" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00830.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00830.java
new file mode 100644
index 0000000000000000000000000000000000000000..2207ca9250633355b294457eef0d4305a6075874
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00830.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00830")
+public class BenchmarkTest00830 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00830" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00830"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00830" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00831.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00831.java
new file mode 100644
index 0000000000000000000000000000000000000000..c80779e0a265722f8716cfd0bc51c6a2365801ad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00831.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00831")
+public class BenchmarkTest00831 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00831" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00831"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00831" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        // Chain a bunch of propagators in sequence
+        String a97193 = param; // assign
+        StringBuilder b97193 = new StringBuilder(a97193); // stick in stringbuilder
+        b97193.append(" SafeStuff"); // append some safe content
+        b97193.replace(
+                b97193.length() - "Chars".length(),
+                b97193.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map97193 = new java.util.HashMap<String, Object>();
+        map97193.put("key97193", b97193.toString()); // put in a collection
+        String c97193 = (String) map97193.get("key97193"); // get it back out
+        String d97193 = c97193.substring(0, c97193.length() - 1); // extract most of it
+        String e97193 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d97193.getBytes()))); // B64 encode and decode it
+        String f97193 = e97193.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g97193 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g97193); // reflection
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00832.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00832.java
new file mode 100644
index 0000000000000000000000000000000000000000..079de1263c577c91e35283f8f3c9e45eef040583
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00832.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00832")
+public class BenchmarkTest00832 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00832" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00832"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00832" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00833.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00833.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d54dd6c46b79c796eddd0fbeac9b52dc2e3fcd7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00833.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00833")
+public class BenchmarkTest00833 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00833" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00833"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00833" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00834.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00834.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d2bd0f33d2787465271a2bbae3086263bfacef2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00834.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00834")
+public class BenchmarkTest00834 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00834" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00834"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00834" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00835.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00835.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ff8c6579b48b9e180bf5b3d630da3f5c35022a7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00835.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00835")
+public class BenchmarkTest00835 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00835" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00835"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00835" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00836.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00836.java
new file mode 100644
index 0000000000000000000000000000000000000000..d01c23a01ce1f720c5ea2459425abab3f5a2c503
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00836.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00836")
+public class BenchmarkTest00836 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00836" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00836"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00836" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00837.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00837.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc2ebbbff08d8946d36bd124abaabbab6c32634a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00837.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00837")
+public class BenchmarkTest00837 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00837" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00837"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00837" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map5936 = new java.util.HashMap<String, Object>();
+        map5936.put("keyA-5936", "a_Value"); // put some stuff in the collection
+        map5936.put("keyB-5936", param); // put it in a collection
+        map5936.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map5936.get("keyB-5936"); // get it back out
+        bar = (String) map5936.get("keyA-5936"); // get safe value back out
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00838.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00838.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1b0f612b05283b220c9465f84799b9a9c1597d4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00838.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00838")
+public class BenchmarkTest00838 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00838" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00838"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00838" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00839.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00839.java
new file mode 100644
index 0000000000000000000000000000000000000000..56da86c785c77d7bbbd82cb11c78304186d94128
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00839.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00839")
+public class BenchmarkTest00839 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00839" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00839"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00839" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00840.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00840.java
new file mode 100644
index 0000000000000000000000000000000000000000..d58ec2fb5e38a3152b62027ff3c1d3ae011edb98
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00840.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00840")
+public class BenchmarkTest00840 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00840" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00840"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00840" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00841.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00841.java
new file mode 100644
index 0000000000000000000000000000000000000000..25930232abe131b082f13ca8ee6ebc53e674dcba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00841.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00841")
+public class BenchmarkTest00841 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00841" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00841"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00841" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00842.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00842.java
new file mode 100644
index 0000000000000000000000000000000000000000..59ce3f24625b45ebcad4ddadddef6a7fe6e49eca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00842.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00842")
+public class BenchmarkTest00842 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00842" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00842"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00842" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00843.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00843.java
new file mode 100644
index 0000000000000000000000000000000000000000..119e71bb73101ed40c18b038e5a8dbf89935a0a0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00843.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00843")
+public class BenchmarkTest00843 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00843" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00843"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00843" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map12983 = new java.util.HashMap<String, Object>();
+        map12983.put("keyA-12983", "a-Value"); // put some stuff in the collection
+        map12983.put("keyB-12983", param); // put it in a collection
+        map12983.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map12983.get("keyB-12983"); // get it back out
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00844.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00844.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad7cee30047d76c80cea9596a6cd79c37fdc4dfd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00844.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00844")
+public class BenchmarkTest00844 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00844" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00844"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00844" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00845.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00845.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ce654185afd537d7f06d9ca21a12c975ffc2925
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00845.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00845")
+public class BenchmarkTest00845 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00845" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00845"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00845" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00846.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00846.java
new file mode 100644
index 0000000000000000000000000000000000000000..a15fb03f0b79d4ae3af6b502be9eb1fde261bfab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00846.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00846")
+public class BenchmarkTest00846 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00846" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00846"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00846" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00847.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00847.java
new file mode 100644
index 0000000000000000000000000000000000000000..d03fc660f7d4df062ceb3feb9c10dc5a4a04dd9e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00847.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00847")
+public class BenchmarkTest00847 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00847" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00847"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00847" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00848.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00848.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb9db379c042b782938972f0dbf1c712c60f2cbc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00848.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00848")
+public class BenchmarkTest00848 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00848" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00848"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00848" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = param;
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00849.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00849.java
new file mode 100644
index 0000000000000000000000000000000000000000..785a38936df2e1c8b07aeb512fa713e9f51c523d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00849.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00849")
+public class BenchmarkTest00849 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00849" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00849"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00849" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00850.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00850.java
new file mode 100644
index 0000000000000000000000000000000000000000..02d5bf181d1930444d51b5e844f5150d04f596f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00850.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00850")
+public class BenchmarkTest00850 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00850" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00850"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00850" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00851.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00851.java
new file mode 100644
index 0000000000000000000000000000000000000000..86b76a29f816c4fd09e83874a3f80ca27fcb6c3b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00851.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00851")
+public class BenchmarkTest00851 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00851" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00851"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00851" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00852.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00852.java
new file mode 100644
index 0000000000000000000000000000000000000000..6610a404a5a690691ebdcaf05a6f7e42dee66f78
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00852.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00852")
+public class BenchmarkTest00852 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest00852" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest00852"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest00852" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map47458 = new java.util.HashMap<String, Object>();
+        map47458.put("keyA-47458", "a_Value"); // put some stuff in the collection
+        map47458.put("keyB-47458", param); // put it in a collection
+        map47458.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map47458.get("keyB-47458"); // get it back out
+        bar = (String) map47458.get("keyA-47458"); // get safe value back out
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00853.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00853.java
new file mode 100644
index 0000000000000000000000000000000000000000..64ce7fdc642825e65fbf6a2ec159a55ec6904270
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00853.java	
@@ -0,0 +1,132 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00853")
+public class BenchmarkTest00853 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00853");
+
+        StringBuilder sbxyz83803 = new StringBuilder(param);
+        String bar = sbxyz83803.append("_SafeStuff").toString();
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00854.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00854.java
new file mode 100644
index 0000000000000000000000000000000000000000..aae929efbaf622e66fab8f21a55d7ff25dd661af
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00854.java	
@@ -0,0 +1,137 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00854")
+public class BenchmarkTest00854 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00854");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00855.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00855.java
new file mode 100644
index 0000000000000000000000000000000000000000..834fe08e89f6e0c5dce3a07976bbd7a796875a93
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00855.java	
@@ -0,0 +1,145 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00855")
+public class BenchmarkTest00855 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00855");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00856.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00856.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b524c26d24c481badd82dc8d95eeaeabca775f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00856.java	
@@ -0,0 +1,121 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00856")
+public class BenchmarkTest00856 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00856");
+
+        // Chain a bunch of propagators in sequence
+        String a98944 = param; // assign
+        StringBuilder b98944 = new StringBuilder(a98944); // stick in stringbuilder
+        b98944.append(" SafeStuff"); // append some safe content
+        b98944.replace(
+                b98944.length() - "Chars".length(),
+                b98944.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map98944 = new java.util.HashMap<String, Object>();
+        map98944.put("key98944", b98944.toString()); // put in a collection
+        String c98944 = (String) map98944.get("key98944"); // get it back out
+        String d98944 = c98944.substring(0, c98944.length() - 1); // extract most of it
+        String e98944 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d98944.getBytes()))); // B64 encode and decode it
+        String f98944 = e98944.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f98944); // reflection
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00857.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00857.java
new file mode 100644
index 0000000000000000000000000000000000000000..bbe9b05f2ba6e6be63a60186e2d34a1a38ec3071
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00857.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00857")
+public class BenchmarkTest00857 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00857");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00858.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00858.java
new file mode 100644
index 0000000000000000000000000000000000000000..5070cfd92b78039a2a7b7229c966bbce7ec126fc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00858.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00858")
+public class BenchmarkTest00858 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00858");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00859.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00859.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a11d0330d7b4441a85e9bd81d9858ca1f91b073
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00859.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00859")
+public class BenchmarkTest00859 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00859");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map87594 = new java.util.HashMap<String, Object>();
+        map87594.put("keyA-87594", "a-Value"); // put some stuff in the collection
+        map87594.put("keyB-87594", param); // put it in a collection
+        map87594.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map87594.get("keyB-87594"); // get it back out
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00860.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00860.java
new file mode 100644
index 0000000000000000000000000000000000000000..8dbd6ff30450c02acd28b96158b37d880fcfe035
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00860.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00860")
+public class BenchmarkTest00860 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00860");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00861.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00861.java
new file mode 100644
index 0000000000000000000000000000000000000000..5df595658b1aeb2e7e07617d095177f9b5d3755e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00861.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00861")
+public class BenchmarkTest00861 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00861");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00862.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00862.java
new file mode 100644
index 0000000000000000000000000000000000000000..9285ee6523cf295a7e21124548fe026b29ff04e9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00862.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00862")
+public class BenchmarkTest00862 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00862");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00863.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00863.java
new file mode 100644
index 0000000000000000000000000000000000000000..369d3d035dd978e99d6110689c2e3dcf894761c2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00863.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00863")
+public class BenchmarkTest00863 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00863");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00864.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00864.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e8a71d97c8e4f908777caa5cef6b1fa77361dfd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00864.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00864")
+public class BenchmarkTest00864 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00864");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00865.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00865.java
new file mode 100644
index 0000000000000000000000000000000000000000..cfda5a461c3cf5c7333c7294c0459c0cebb4fd0d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00865.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-00/BenchmarkTest00865")
+public class BenchmarkTest00865 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00865");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00866.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00866.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f5c7f21103f167583a5d3278ee4ae01642ab56a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00866.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00866")
+public class BenchmarkTest00866 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00866");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00867.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00867.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6391816c13c44812f0e2d4e30ea18f34a6f6353
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00867.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00867")
+public class BenchmarkTest00867 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00867");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00868.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00868.java
new file mode 100644
index 0000000000000000000000000000000000000000..99c4be5534ad30531962aa1127e04667449bd11c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00868.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00868")
+public class BenchmarkTest00868 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00868");
+
+        // Chain a bunch of propagators in sequence
+        String a51118 = param; // assign
+        StringBuilder b51118 = new StringBuilder(a51118); // stick in stringbuilder
+        b51118.append(" SafeStuff"); // append some safe content
+        b51118.replace(
+                b51118.length() - "Chars".length(),
+                b51118.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map51118 = new java.util.HashMap<String, Object>();
+        map51118.put("key51118", b51118.toString()); // put in a collection
+        String c51118 = (String) map51118.get("key51118"); // get it back out
+        String d51118 = c51118.substring(0, c51118.length() - 1); // extract most of it
+        String e51118 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d51118.getBytes()))); // B64 encode and decode it
+        String f51118 = e51118.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f51118); // reflection
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00869.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00869.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f159cdf1ae1e9855abeb9b543b80dff5379bfb0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00869.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00869")
+public class BenchmarkTest00869 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00869");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00870.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00870.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f34b533e72d00cc5f98ca3751fe0a414b5f0bc5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00870.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00870")
+public class BenchmarkTest00870 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00870");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00871.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00871.java
new file mode 100644
index 0000000000000000000000000000000000000000..b852473d884f10aef75aa8e88d4ff5ace400d0d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00871.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00871")
+public class BenchmarkTest00871 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00871");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map42157 = new java.util.HashMap<String, Object>();
+        map42157.put("keyA-42157", "a-Value"); // put some stuff in the collection
+        map42157.put("keyB-42157", param); // put it in a collection
+        map42157.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map42157.get("keyB-42157"); // get it back out
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00872.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00872.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ab4611eef756c88f5d118bbb1b252b187e9ed91
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00872.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00872")
+public class BenchmarkTest00872 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00872");
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00873.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00873.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d62998e517a80c19dd70203645ce84227db28c1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00873.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00873")
+public class BenchmarkTest00873 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00873");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map58847 = new java.util.HashMap<String, Object>();
+        map58847.put("keyA-58847", "a_Value"); // put some stuff in the collection
+        map58847.put("keyB-58847", param); // put it in a collection
+        map58847.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map58847.get("keyB-58847"); // get it back out
+        bar = (String) map58847.get("keyA-58847"); // get safe value back out
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00874.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00874.java
new file mode 100644
index 0000000000000000000000000000000000000000..4216bed3d6e91736533ef95f68890608bb511714
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00874.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00874")
+public class BenchmarkTest00874 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00874");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00875.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00875.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d2080e24584abc1b2a55842b50710d7366b3ccf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00875.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00875")
+public class BenchmarkTest00875 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00875");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00876.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00876.java
new file mode 100644
index 0000000000000000000000000000000000000000..36f6341447c54c28808f34aca235bb32662c49e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00876.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00876")
+public class BenchmarkTest00876 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00876");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00877.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00877.java
new file mode 100644
index 0000000000000000000000000000000000000000..cba2f1eb2f0d046ed9ff6759e7dc81364bf9d145
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00877.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00877")
+public class BenchmarkTest00877 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00877");
+
+        // Chain a bunch of propagators in sequence
+        String a55741 = param; // assign
+        StringBuilder b55741 = new StringBuilder(a55741); // stick in stringbuilder
+        b55741.append(" SafeStuff"); // append some safe content
+        b55741.replace(
+                b55741.length() - "Chars".length(),
+                b55741.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map55741 = new java.util.HashMap<String, Object>();
+        map55741.put("key55741", b55741.toString()); // put in a collection
+        String c55741 = (String) map55741.get("key55741"); // get it back out
+        String d55741 = c55741.substring(0, c55741.length() - 1); // extract most of it
+        String e55741 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d55741.getBytes()))); // B64 encode and decode it
+        String f55741 = e55741.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f55741); // reflection
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00878.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00878.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b2b04308117b999670fd560c1bd4da460c1f9c2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00878.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00878")
+public class BenchmarkTest00878 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00878");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00879.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00879.java
new file mode 100644
index 0000000000000000000000000000000000000000..52ceb3a7a1eee145640883d76096ade62f2037e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00879.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00879")
+public class BenchmarkTest00879 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00879");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map11407 = new java.util.HashMap<String, Object>();
+        map11407.put("keyA-11407", "a_Value"); // put some stuff in the collection
+        map11407.put("keyB-11407", param); // put it in a collection
+        map11407.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map11407.get("keyB-11407"); // get it back out
+        bar = (String) map11407.get("keyA-11407"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00880.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00880.java
new file mode 100644
index 0000000000000000000000000000000000000000..d66bde31f4660066ce92cc8b2725c699643c4916
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00880.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00880")
+public class BenchmarkTest00880 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00880");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00881.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00881.java
new file mode 100644
index 0000000000000000000000000000000000000000..85b3acf99f949ec64e2060510a5cd0f119d21c11
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00881.java	
@@ -0,0 +1,39 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00881")
+public class BenchmarkTest00881 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00881");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00882.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00882.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bb7a6a318c8eb03368fffdb86bd15e714889f9b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00882.java	
@@ -0,0 +1,39 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00882")
+public class BenchmarkTest00882 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00882");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00883.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00883.java
new file mode 100644
index 0000000000000000000000000000000000000000..583c45565b0ce491e0db6c625e732b51b95f7ef7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00883.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00883")
+public class BenchmarkTest00883 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00883");
+
+        // Chain a bunch of propagators in sequence
+        String a69063 = param; // assign
+        StringBuilder b69063 = new StringBuilder(a69063); // stick in stringbuilder
+        b69063.append(" SafeStuff"); // append some safe content
+        b69063.replace(
+                b69063.length() - "Chars".length(),
+                b69063.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map69063 = new java.util.HashMap<String, Object>();
+        map69063.put("key69063", b69063.toString()); // put in a collection
+        String c69063 = (String) map69063.get("key69063"); // get it back out
+        String d69063 = c69063.substring(0, c69063.length() - 1); // extract most of it
+        String e69063 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d69063.getBytes()))); // B64 encode and decode it
+        String f69063 = e69063.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f69063); // reflection
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00884.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00884.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5a12439ce4b5e71f2c1898e4e7172fe0d2de7f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00884.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00884")
+public class BenchmarkTest00884 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00884");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map26388 = new java.util.HashMap<String, Object>();
+        map26388.put("keyA-26388", "a_Value"); // put some stuff in the collection
+        map26388.put("keyB-26388", param); // put it in a collection
+        map26388.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map26388.get("keyB-26388"); // get it back out
+        bar = (String) map26388.get("keyA-26388"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00885.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00885.java
new file mode 100644
index 0000000000000000000000000000000000000000..602a8df40439f62edd21c5daa53961815d8d8e67
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00885.java	
@@ -0,0 +1,39 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00885")
+public class BenchmarkTest00885 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00885");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz28240 = new StringBuilder(param);
+            bar = sbxyz28240.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00886.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00886.java
new file mode 100644
index 0000000000000000000000000000000000000000..e71b3ffa75c8926fe5b679bd299fa51e91cc9452
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00886.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00886")
+public class BenchmarkTest00886 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00886");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map8361 = new java.util.HashMap<String, Object>();
+        map8361.put("keyA-8361", "a_Value"); // put some stuff in the collection
+        map8361.put("keyB-8361", param); // put it in a collection
+        map8361.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map8361.get("keyB-8361"); // get it back out
+        bar = (String) map8361.get("keyA-8361"); // get safe value back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00887.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00887.java
new file mode 100644
index 0000000000000000000000000000000000000000..300a712f5779bc3bae68bafe0d9100b971a43aa0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00887.java	
@@ -0,0 +1,39 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00887")
+public class BenchmarkTest00887 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00887");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map39726 = new java.util.HashMap<String, Object>();
+        map39726.put("keyA-39726", "a-Value"); // put some stuff in the collection
+        map39726.put("keyB-39726", param); // put it in a collection
+        map39726.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map39726.get("keyB-39726"); // get it back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00888.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00888.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb8363aeeb9011d9b4c0fede4e864db48d1eaa4c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00888.java	
@@ -0,0 +1,34 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00888")
+public class BenchmarkTest00888 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00888");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00889.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00889.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e4c359cd44c54893c0841ca53ebe4411f4f01dd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00889.java	
@@ -0,0 +1,39 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00889")
+public class BenchmarkTest00889 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00889");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00890.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00890.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c5dec861faed4ca8dc19515c5f0597a2a1f5fcc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00890.java	
@@ -0,0 +1,39 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00890")
+public class BenchmarkTest00890 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00890");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map61765 = new java.util.HashMap<String, Object>();
+        map61765.put("keyA-61765", "a-Value"); // put some stuff in the collection
+        map61765.put("keyB-61765", param); // put it in a collection
+        map61765.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map61765.get("keyB-61765"); // get it back out
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00891.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00891.java
new file mode 100644
index 0000000000000000000000000000000000000000..c77642c2da7eaeff317bb24ed11a851463e86a64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00891.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00891")
+public class BenchmarkTest00891 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00891");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00892.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00892.java
new file mode 100644
index 0000000000000000000000000000000000000000..a078570d49a8ca0095aeeffbadb21913f91f86e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00892.java	
@@ -0,0 +1,38 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00892")
+public class BenchmarkTest00892 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00892");
+
+        String bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00893.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00893.java
new file mode 100644
index 0000000000000000000000000000000000000000..e86cf9408389deb00c321eaaaf39329378d12ca9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00893.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00893")
+public class BenchmarkTest00893 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00893");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00894.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00894.java
new file mode 100644
index 0000000000000000000000000000000000000000..5958d8f72fce8ce828adc8df54e3c18a9c28743f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00894.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest00894")
+public class BenchmarkTest00894 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00894");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00895.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00895.java
new file mode 100644
index 0000000000000000000000000000000000000000..be20086b33961cda6a4faddcba7a8d616a8013ef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00895.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00895")
+public class BenchmarkTest00895 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00895");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00896.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00896.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b8fd46e59c196fbe37a02a28414e29e09143e39
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00896.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00896")
+public class BenchmarkTest00896 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00896");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00897.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00897.java
new file mode 100644
index 0000000000000000000000000000000000000000..719313fa7f365bb4b7497e41ec3208cfe4d93fda
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00897.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00897")
+public class BenchmarkTest00897 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00897");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00898.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00898.java
new file mode 100644
index 0000000000000000000000000000000000000000..807327d0c6f2abba84289cece014b9557173ac9c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00898.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00898")
+public class BenchmarkTest00898 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00898");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00899.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00899.java
new file mode 100644
index 0000000000000000000000000000000000000000..41449f43db2af5088560dab18fb2cfdc9368f8cd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00899.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00899")
+public class BenchmarkTest00899 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00899");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00900.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00900.java
new file mode 100644
index 0000000000000000000000000000000000000000..47ec809d517b91f1af3711cdb263f9a6385c9863
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00900.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00900")
+public class BenchmarkTest00900 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00900");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00901.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00901.java
new file mode 100644
index 0000000000000000000000000000000000000000..f23468cab4a914b8d22974296a23290586a51592
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00901.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00901")
+public class BenchmarkTest00901 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00901");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00902.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00902.java
new file mode 100644
index 0000000000000000000000000000000000000000..1675641fbfb933c4444a8913514c56e7b04b5383
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00902.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-01/BenchmarkTest00902")
+public class BenchmarkTest00902 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00902");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map21609 = new java.util.HashMap<String, Object>();
+        map21609.put("keyA-21609", "a-Value"); // put some stuff in the collection
+        map21609.put("keyB-21609", param); // put it in a collection
+        map21609.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map21609.get("keyB-21609"); // get it back out
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00903.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00903.java
new file mode 100644
index 0000000000000000000000000000000000000000..014ae15d0fe5a5fe440d6e5b1c5079a2257577ab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00903.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00903")
+public class BenchmarkTest00903 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00903");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00904.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00904.java
new file mode 100644
index 0000000000000000000000000000000000000000..116fa23ae07248665132af733b326449fe540269
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00904.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00904")
+public class BenchmarkTest00904 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00904");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00905.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00905.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9d401eb276eb57fd987f22712c7732ae0baec13
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00905.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00905")
+public class BenchmarkTest00905 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00905");
+
+        String bar = param;
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00906.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00906.java
new file mode 100644
index 0000000000000000000000000000000000000000..344cf384b210f8ceb89a031bf90beb4be7a28532
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00906.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00906")
+public class BenchmarkTest00906 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00906");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00907.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00907.java
new file mode 100644
index 0000000000000000000000000000000000000000..780c7a2cb49f81d55413e17d8db179b391d0f412
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00907.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00907")
+public class BenchmarkTest00907 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00907");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00908.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00908.java
new file mode 100644
index 0000000000000000000000000000000000000000..5512c590e2a7b11c0599fd7a7bd2be42b0b3e0b7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00908.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00908")
+public class BenchmarkTest00908 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00908");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00909.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00909.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bb02dbaa69b9ebe5510d612c7cd420504369dee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00909.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00909")
+public class BenchmarkTest00909 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00909");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00910.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00910.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce8422679458e9eb718c7714836564a7dd998584
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00910.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00910")
+public class BenchmarkTest00910 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00910");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00911.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00911.java
new file mode 100644
index 0000000000000000000000000000000000000000..60fd29f4070882ec68275b355c72fd3730e129c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00911.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00911")
+public class BenchmarkTest00911 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00911");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00912.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00912.java
new file mode 100644
index 0000000000000000000000000000000000000000..63ad3e7203600c07c5561f55f63241eac5f934e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00912.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00912")
+public class BenchmarkTest00912 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00912");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00913.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00913.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5d6b1c68af8587144abee5ec8f24f2d3b49d9ea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00913.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00913")
+public class BenchmarkTest00913 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00913");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00914.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00914.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ca83630880ea7d02aff41a4cb3b2feaa500385e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00914.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00914")
+public class BenchmarkTest00914 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00914");
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00915.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00915.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e49f79c2dad03dd71bf4da21e6e489175993d6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00915.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00915")
+public class BenchmarkTest00915 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00915");
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00916.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00916.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a4854b03cf9bc929a7033f22279b45aded8e3af
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00916.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00916")
+public class BenchmarkTest00916 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00916");
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00917.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00917.java
new file mode 100644
index 0000000000000000000000000000000000000000..565de905c6decf86ca40c4744402d5bb33c18230
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00917.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00917")
+public class BenchmarkTest00917 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00917");
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map5880 = new java.util.HashMap<String, Object>();
+        map5880.put("keyA-5880", "a_Value"); // put some stuff in the collection
+        map5880.put("keyB-5880", param); // put it in a collection
+        map5880.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map5880.get("keyB-5880"); // get it back out
+        bar = (String) map5880.get("keyA-5880"); // get safe value back out
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00918.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00918.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a49e68a3b0633d5125deb81d160291cbaa42774
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00918.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00918")
+public class BenchmarkTest00918 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00918");
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00919.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00919.java
new file mode 100644
index 0000000000000000000000000000000000000000..04b2fc8587fd274fb85daeb5bf16ae2a0f75f7f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00919.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00919")
+public class BenchmarkTest00919 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00919");
+
+        String bar = param;
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00920.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00920.java
new file mode 100644
index 0000000000000000000000000000000000000000..9321ba47e3ead3a9a7653534ba54f446e7432809
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00920.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00920")
+public class BenchmarkTest00920 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00920");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00921.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00921.java
new file mode 100644
index 0000000000000000000000000000000000000000..6af2778569142c599b32ec55fb26f727373d5c07
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00921.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00921")
+public class BenchmarkTest00921 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00921");
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00922.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00922.java
new file mode 100644
index 0000000000000000000000000000000000000000..82e46a62410725895e4fc41031e403eb2c23783b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00922.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00922")
+public class BenchmarkTest00922 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00922");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00923.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00923.java
new file mode 100644
index 0000000000000000000000000000000000000000..250402168036dab47c3069dfc16cdf18a51bf737
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00923.java	
@@ -0,0 +1,40 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00923")
+public class BenchmarkTest00923 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00923");
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00924.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00924.java
new file mode 100644
index 0000000000000000000000000000000000000000..4935785c4456df4caa7703bd41b7c925f993a5f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00924.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00924")
+public class BenchmarkTest00924 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00924");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00925.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00925.java
new file mode 100644
index 0000000000000000000000000000000000000000..d199194aae17d1d72142723c5c366eaeacf2bbb5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00925.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00925")
+public class BenchmarkTest00925 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00925");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00926.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00926.java
new file mode 100644
index 0000000000000000000000000000000000000000..eaece0c9acf4044cbbcfa7f605d646e74f3ed46f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00926.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00926")
+public class BenchmarkTest00926 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00926");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00927.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00927.java
new file mode 100644
index 0000000000000000000000000000000000000000..4395f0c27ce2fd00e9255629a71be9f80ae8e092
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00927.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00927")
+public class BenchmarkTest00927 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00927");
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00928.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00928.java
new file mode 100644
index 0000000000000000000000000000000000000000..fcffef53e7f5aa58744142d05e52d5cf9039ddca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00928.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00928")
+public class BenchmarkTest00928 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00928");
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00929.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00929.java
new file mode 100644
index 0000000000000000000000000000000000000000..5bc5a331292c30651acbb0ba16e8552cc2829081
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00929.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00929")
+public class BenchmarkTest00929 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00929");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00930.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00930.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3f48d2e8529590db12c84042fcd27ec15280602
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00930.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00930")
+public class BenchmarkTest00930 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00930");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00931.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00931.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b3455a9153ced797fc4b0c0f0c468f82b9e71e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00931.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00931")
+public class BenchmarkTest00931 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00931");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00932.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00932.java
new file mode 100644
index 0000000000000000000000000000000000000000..e00454bc7740951cd88d9b9f57cfaa0c7e69dd40
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00932.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00932")
+public class BenchmarkTest00932 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00932");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00933.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00933.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b788189da9508e1afe831162a082490cd940c8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00933.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00933")
+public class BenchmarkTest00933 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00933");
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00934.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00934.java
new file mode 100644
index 0000000000000000000000000000000000000000..f901aec94577aa732f25fbdf349929daaabff218
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00934.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00934")
+public class BenchmarkTest00934 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00934");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00935.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00935.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1ed0989e25aac34d0bfadac274c355c918aa0d5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00935.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-01/BenchmarkTest00935")
+public class BenchmarkTest00935 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00935");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00936.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00936.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2495461f4fd2f1ec94dd6a8f1beef40ac1f9823
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00936.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00936")
+public class BenchmarkTest00936 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00936");
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00937.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00937.java
new file mode 100644
index 0000000000000000000000000000000000000000..4121da3718793ba9324542348351d133dfbd56c6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00937.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00937")
+public class BenchmarkTest00937 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00937");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00938.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00938.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c3187ff073415dcf9c3e5bb26cbf27a9fb4354f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00938.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00938")
+public class BenchmarkTest00938 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00938");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00939.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00939.java
new file mode 100644
index 0000000000000000000000000000000000000000..154aa2e2295f46f551d7ce754eb247282396c969
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00939.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00939")
+public class BenchmarkTest00939 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00939");
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00940.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00940.java
new file mode 100644
index 0000000000000000000000000000000000000000..606d52f657aefca5f82e05afe5a4bdd8368ab2d7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00940.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00940")
+public class BenchmarkTest00940 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00940");
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00941.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00941.java
new file mode 100644
index 0000000000000000000000000000000000000000..162a47bc4e0e66242f50c19b5e80bcc64234e014
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00941.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest00941")
+public class BenchmarkTest00941 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest00941");
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00942.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00942.java
new file mode 100644
index 0000000000000000000000000000000000000000..6877e9672e8ef53a0ba287000d8671064a10d8f3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00942.java	
@@ -0,0 +1,168 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00942")
+public class BenchmarkTest00942 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00942", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-01/BenchmarkTest00942.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00942")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00943.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00943.java
new file mode 100644
index 0000000000000000000000000000000000000000..51791cf4bea208678f3fdfb8882ce4f926b9517b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00943.java	
@@ -0,0 +1,130 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00943")
+public class BenchmarkTest00943 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00943", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-01/BenchmarkTest00943.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00943")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00944.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00944.java
new file mode 100644
index 0000000000000000000000000000000000000000..3fe3befb42c4fc892e49843133b5a2f9a9fcc2fe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00944.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00944")
+public class BenchmarkTest00944 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00944", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-01/BenchmarkTest00944.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00944")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00945.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00945.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b4482e3d80cd2f211518fc15518ab2f0a0207d5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00945.java	
@@ -0,0 +1,131 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00945")
+public class BenchmarkTest00945 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00945", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-01/BenchmarkTest00945.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00945")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00946.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00946.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b44c9ae9299f4f6fc3a0e0f7859fa3e1eb2eae5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00946.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest00946")
+public class BenchmarkTest00946 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00946", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-01/BenchmarkTest00946.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00946")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00947.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00947.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7f394bfe6158824479ae28382760b7b84e6dde0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00947.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00947")
+public class BenchmarkTest00947 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00947", "Ms+Bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/ldapi-00/BenchmarkTest00947.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00947")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00948.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00948.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a64b931b2164cab6098c687df7a677a32cd2819
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00948.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00948")
+public class BenchmarkTest00948 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00948", "Ms+Bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/ldapi-00/BenchmarkTest00948.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00948")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map72608 = new java.util.HashMap<String, Object>();
+            map72608.put("keyA-72608", "a_Value"); // put some stuff in the collection
+            map72608.put("keyB-72608", param); // put it in a collection
+            map72608.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map72608.get("keyB-72608"); // get it back out
+            bar = (String) map72608.get("keyA-72608"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00949.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00949.java
new file mode 100644
index 0000000000000000000000000000000000000000..67f0ad6bf6792a795a9568768b6fb9339170faff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00949.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00949")
+public class BenchmarkTest00949 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00949", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00949.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00949")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00950.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00950.java
new file mode 100644
index 0000000000000000000000000000000000000000..03a19fb8c8595fcde8229dff11e2bbc327086138
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00950.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00950")
+public class BenchmarkTest00950 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00950", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00950.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00950")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00951.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00951.java
new file mode 100644
index 0000000000000000000000000000000000000000..621a738f092131da18d7f2e33ce748f8eafe6f7a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00951.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00951")
+public class BenchmarkTest00951 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00951", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00951.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00951")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00952.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00952.java
new file mode 100644
index 0000000000000000000000000000000000000000..727a5f8964516b059eec72054c304981f36628fb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00952.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00952")
+public class BenchmarkTest00952 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00952", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00952.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00952")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00953.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00953.java
new file mode 100644
index 0000000000000000000000000000000000000000..12c6225c3eae711ee372a9ac3e97526731e80e48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00953.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00953")
+public class BenchmarkTest00953 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00953", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00953.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00953")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00954.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00954.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9161d465625ea453e465810ecdd38ea9f558a17
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00954.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00954")
+public class BenchmarkTest00954 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00954", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00954.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00954")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map9749 = new java.util.HashMap<String, Object>();
+            map9749.put("keyA-9749", "a_Value"); // put some stuff in the collection
+            map9749.put("keyB-9749", param); // put it in a collection
+            map9749.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map9749.get("keyB-9749"); // get it back out
+            bar = (String) map9749.get("keyA-9749"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00955.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00955.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee71a26d497538f97ae59375938bf5ca6543c6ae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00955.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00955")
+public class BenchmarkTest00955 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00955", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00955.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00955")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00956.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00956.java
new file mode 100644
index 0000000000000000000000000000000000000000..28a0c110afd76c84fd654974a7f700ec154855b1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00956.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00956")
+public class BenchmarkTest00956 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00956", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00956.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00956")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00957.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00957.java
new file mode 100644
index 0000000000000000000000000000000000000000..f32cee7209bd7e31f8474bc610a15134c491d925
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00957.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00957")
+public class BenchmarkTest00957 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00957", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00957.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00957")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00958.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00958.java
new file mode 100644
index 0000000000000000000000000000000000000000..39c7f0903cc91a4ef3e87fb3dd5be2e0d8f309b9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00958.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest00958")
+public class BenchmarkTest00958 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00958", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-01/BenchmarkTest00958.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00958")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map37053 = new java.util.HashMap<String, Object>();
+            map37053.put("keyA-37053", "a_Value"); // put some stuff in the collection
+            map37053.put("keyB-37053", param); // put it in a collection
+            map37053.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map37053.get("keyB-37053"); // get it back out
+            bar = (String) map37053.get("keyA-37053"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00959.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00959.java
new file mode 100644
index 0000000000000000000000000000000000000000..626ac2aefabee41607646e59295b947e8e5568eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00959.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest00959")
+public class BenchmarkTest00959 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00959", "Ms+Bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/ldapi-00/BenchmarkTest00959.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00959")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00960.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00960.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d0905e6867325bed04ff8651ce8132a322cc73b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00960.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00960")
+public class BenchmarkTest00960 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00960", "anything");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00960.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00960")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map19964 = new java.util.HashMap<String, Object>();
+            map19964.put("keyA-19964", "a_Value"); // put some stuff in the collection
+            map19964.put("keyB-19964", param); // put it in a collection
+            map19964.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map19964.get("keyB-19964"); // get it back out
+            bar = (String) map19964.get("keyA-19964"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00961.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00961.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ec963739daaf47b0147a99ba7cae3a5f6099dde
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00961.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00961")
+public class BenchmarkTest00961 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00961", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-01/BenchmarkTest00961.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00961")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map47722 = new java.util.HashMap<String, Object>();
+            map47722.put("keyA-47722", "a_Value"); // put some stuff in the collection
+            map47722.put("keyB-47722", param); // put it in a collection
+            map47722.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map47722.get("keyB-47722"); // get it back out
+            bar = (String) map47722.get("keyA-47722"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00962.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00962.java
new file mode 100644
index 0000000000000000000000000000000000000000..274d1bb9a9fb2aadb0dddde525ea99d6cee0cf6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00962.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00962")
+public class BenchmarkTest00962 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00962", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-01/BenchmarkTest00962.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00962")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00963.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00963.java
new file mode 100644
index 0000000000000000000000000000000000000000..4caf0a69b5c2356716ebaf712dd8cf6d6151da59
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00963.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00963")
+public class BenchmarkTest00963 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00963", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-01/BenchmarkTest00963.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00963")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00964.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00964.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8166db4591edd6505f7a4f438709efc5bc6f3a4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00964.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00964")
+public class BenchmarkTest00964 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00964", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-01/BenchmarkTest00964.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00964")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00965.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00965.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3213a3608f6562a9ee77cbba53a64cf39d813f9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00965.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00965")
+public class BenchmarkTest00965 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00965", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-01/BenchmarkTest00965.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00965")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map47189 = new java.util.HashMap<String, Object>();
+            map47189.put("keyA-47189", "a-Value"); // put some stuff in the collection
+            map47189.put("keyB-47189", param); // put it in a collection
+            map47189.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map47189.get("keyB-47189"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00966.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00966.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8c7cf399100927957ecee7d246391d12e009a2f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00966.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00966")
+public class BenchmarkTest00966 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00966", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-01/BenchmarkTest00966.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00966")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00967.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00967.java
new file mode 100644
index 0000000000000000000000000000000000000000..a54e11ca6a5f6803462969e616ef5da7ff4c0857
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00967.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest00967")
+public class BenchmarkTest00967 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00967", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-01/BenchmarkTest00967.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00967")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00968.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00968.java
new file mode 100644
index 0000000000000000000000000000000000000000..154fbaf7f49c947d19358aecae9e9ce75f2c0303
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00968.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00968")
+public class BenchmarkTest00968 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00968", "ECHOOO");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00968.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00968")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00969.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00969.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fe1e33956a1d118a2aac72443af5416ea1a3947
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00969.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00969")
+public class BenchmarkTest00969 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00969", "ECHOOO");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00969.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00969")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a10263 = param; // assign
+            StringBuilder b10263 = new StringBuilder(a10263); // stick in stringbuilder
+            b10263.append(" SafeStuff"); // append some safe content
+            b10263.replace(
+                    b10263.length() - "Chars".length(),
+                    b10263.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map10263 = new java.util.HashMap<String, Object>();
+            map10263.put("key10263", b10263.toString()); // put in a collection
+            String c10263 = (String) map10263.get("key10263"); // get it back out
+            String d10263 = c10263.substring(0, c10263.length() - 1); // extract most of it
+            String e10263 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d10263.getBytes()))); // B64 encode and decode it
+            String f10263 = e10263.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g10263 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g10263); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00970.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00970.java
new file mode 100644
index 0000000000000000000000000000000000000000..feb38c32a65fccb12ae16ab647909c63f51cd31c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00970.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00970")
+public class BenchmarkTest00970 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00970", "ECHOOO");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00970.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00970")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00971.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00971.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9fb178d90b21780b7332ea52443c77010fde8d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00971.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00971")
+public class BenchmarkTest00971 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00971", "does_not_matter");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00971.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00971")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00972.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00972.java
new file mode 100644
index 0000000000000000000000000000000000000000..8cd6a7db125b2c523a963780983616d3da865f3e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00972.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00972")
+public class BenchmarkTest00972 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00972", "does_not_matter");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00972.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00972")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map73877 = new java.util.HashMap<String, Object>();
+            map73877.put("keyA-73877", "a_Value"); // put some stuff in the collection
+            map73877.put("keyB-73877", param); // put it in a collection
+            map73877.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map73877.get("keyB-73877"); // get it back out
+            bar = (String) map73877.get("keyA-73877"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00973.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00973.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f49b7db7a1e470410a21c9ef1e9928e74e8326a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00973.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00973")
+public class BenchmarkTest00973 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00973", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00973.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00973")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00974.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00974.java
new file mode 100644
index 0000000000000000000000000000000000000000..571830b17a82e6dab2cbdf7ec2fae19100033f13
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00974.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00974")
+public class BenchmarkTest00974 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00974", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00974.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00974")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00975.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00975.java
new file mode 100644
index 0000000000000000000000000000000000000000..06e61609f4c547d9d9210d186773f0acabe08da2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00975.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00975")
+public class BenchmarkTest00975 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00975", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00975.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00975")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00976.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00976.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8a1195060d2530de31185cf418cd2bd97e8c297
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00976.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00976")
+public class BenchmarkTest00976 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00976", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00976.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00976")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00977.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00977.java
new file mode 100644
index 0000000000000000000000000000000000000000..5df4fa1679cc92a9fff8813539509e9c67efcf03
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00977.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest00977")
+public class BenchmarkTest00977 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00977", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/securecookie-00/BenchmarkTest00977.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00977")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00978.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00978.java
new file mode 100644
index 0000000000000000000000000000000000000000..09bbbd7d89e0f6d215880e6248b22f1c75bb9a8b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00978.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00978")
+public class BenchmarkTest00978 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00978", "localhost");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00978.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00978")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a60830 = param; // assign
+            StringBuilder b60830 = new StringBuilder(a60830); // stick in stringbuilder
+            b60830.append(" SafeStuff"); // append some safe content
+            b60830.replace(
+                    b60830.length() - "Chars".length(),
+                    b60830.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map60830 = new java.util.HashMap<String, Object>();
+            map60830.put("key60830", b60830.toString()); // put in a collection
+            String c60830 = (String) map60830.get("key60830"); // get it back out
+            String d60830 = c60830.substring(0, c60830.length() - 1); // extract most of it
+            String e60830 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d60830.getBytes()))); // B64 encode and decode it
+            String f60830 = e60830.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g60830 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g60830); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00979.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00979.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ec28280a46238808699824c2ec3cd477c410614
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00979.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00979")
+public class BenchmarkTest00979 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00979", ".");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00979.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00979")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00980.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00980.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ec7318e822f619bded306c226752e258faa8140
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00980.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00980")
+public class BenchmarkTest00980 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00980", "FOO%3Decho+Injection");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00980.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00980")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00981.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00981.java
new file mode 100644
index 0000000000000000000000000000000000000000..7cc7620fc85c9618981c8940423933260dea76c8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00981.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00981")
+public class BenchmarkTest00981 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00981", ".");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00981.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00981")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00982.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00982.java
new file mode 100644
index 0000000000000000000000000000000000000000..cdb605d8ab2d73e75ac7081358d8477f2a5c0e54
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00982.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00982")
+public class BenchmarkTest00982 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00982", "FOO%3Decho+Injection");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00982.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00982")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map20875 = new java.util.HashMap<String, Object>();
+            map20875.put("keyA-20875", "a_Value"); // put some stuff in the collection
+            map20875.put("keyB-20875", param); // put it in a collection
+            map20875.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map20875.get("keyB-20875"); // get it back out
+            bar = (String) map20875.get("keyA-20875"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00983.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00983.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f8083d56e378639c68c8db38a19e1efcd7a086a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00983.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest00983")
+public class BenchmarkTest00983 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00983", "FOO%3Decho+Injection");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-01/BenchmarkTest00983.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00983")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00984.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00984.java
new file mode 100644
index 0000000000000000000000000000000000000000..1fc147ca38f543f3182be1bb8007402d4a4c4668
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00984.java	
@@ -0,0 +1,143 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00984")
+public class BenchmarkTest00984 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00984", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00984.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00984")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a50427 = param; // assign
+            StringBuilder b50427 = new StringBuilder(a50427); // stick in stringbuilder
+            b50427.append(" SafeStuff"); // append some safe content
+            b50427.replace(
+                    b50427.length() - "Chars".length(),
+                    b50427.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map50427 = new java.util.HashMap<String, Object>();
+            map50427.put("key50427", b50427.toString()); // put in a collection
+            String c50427 = (String) map50427.get("key50427"); // get it back out
+            String d50427 = c50427.substring(0, c50427.length() - 1); // extract most of it
+            String e50427 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d50427.getBytes()))); // B64 encode and decode it
+            String f50427 = e50427.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g50427 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g50427); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00985.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00985.java
new file mode 100644
index 0000000000000000000000000000000000000000..2030f8f526cefea82311d8194d4932259dff794e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00985.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00985")
+public class BenchmarkTest00985 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00985", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00985.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00985")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz77085 = new StringBuilder(param);
+                bar =
+                        sbxyz77085
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00986.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00986.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a15dade4a850aac156afda204cfbe94c86f852e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00986.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00986")
+public class BenchmarkTest00986 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00986", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00986.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00986")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00987.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00987.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d048f16299792fc1387c2f6d645a42ed2ac5222
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00987.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00987")
+public class BenchmarkTest00987 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00987", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00987.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00987")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00988.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00988.java
new file mode 100644
index 0000000000000000000000000000000000000000..0569d3c4f2cec35cfe3b26bf10b6a138bd7fd0c4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00988.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00988")
+public class BenchmarkTest00988 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00988", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00988.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00988")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00989.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00989.java
new file mode 100644
index 0000000000000000000000000000000000000000..12a7cd58900cf73c767d311b38642d5827c5065f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00989.java	
@@ -0,0 +1,134 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00989")
+public class BenchmarkTest00989 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00989", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00989.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00989")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a36538 = param; // assign
+            StringBuilder b36538 = new StringBuilder(a36538); // stick in stringbuilder
+            b36538.append(" SafeStuff"); // append some safe content
+            b36538.replace(
+                    b36538.length() - "Chars".length(),
+                    b36538.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map36538 = new java.util.HashMap<String, Object>();
+            map36538.put("key36538", b36538.toString()); // put in a collection
+            String c36538 = (String) map36538.get("key36538"); // get it back out
+            String d36538 = c36538.substring(0, c36538.length() - 1); // extract most of it
+            String e36538 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d36538.getBytes()))); // B64 encode and decode it
+            String f36538 = e36538.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f36538); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00990.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00990.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d6be11f30a491c00332a321951932b957bb9385
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00990.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest00990")
+public class BenchmarkTest00990 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00990", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-02/BenchmarkTest00990.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00990")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00991.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00991.java
new file mode 100644
index 0000000000000000000000000000000000000000..ffe545c0d9d609d9ba1c92ea4ac0058e454d85dd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00991.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00991")
+public class BenchmarkTest00991 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00991", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00991.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00991")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00992.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00992.java
new file mode 100644
index 0000000000000000000000000000000000000000..82ecf6c37b51c69c42d535c84d7623e6b9d7c71e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00992.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00992")
+public class BenchmarkTest00992 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00992", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00992.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00992")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00993.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00993.java
new file mode 100644
index 0000000000000000000000000000000000000000..d864efdbcbeb125f84b4f775e0bc93f7956abcaf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00993.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00993")
+public class BenchmarkTest00993 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00993", "my_user_id");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00993.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00993")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00994.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00994.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c38d0af0a2a5137c66ce002d31300d0600eb22b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00994.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00994")
+public class BenchmarkTest00994 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00994", "my_user_id");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00994.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00994")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00995.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00995.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1f4f441883dacd539913f31fe2779552ebb02b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00995.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest00995")
+public class BenchmarkTest00995 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest00995", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-00/BenchmarkTest00995.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00995")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00996.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00996.java
new file mode 100644
index 0000000000000000000000000000000000000000..006145b81434b276ce4ff1756975ce4836861786
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00996.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00996")
+public class BenchmarkTest00996 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie(
+                        "BenchmarkTest00996", "verifyUserPassword%28%27foo%27%2C%27bar%27%29");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest00996.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00996")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00997.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00997.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c93eb130825a7ca538c8437918e372a3f9a4014
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00997.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00997")
+public class BenchmarkTest00997 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie(
+                        "BenchmarkTest00997", "verifyUserPassword%28%27foo%27%2C%27bar%27%29");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest00997.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00997")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00998.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00998.java
new file mode 100644
index 0000000000000000000000000000000000000000..36fd7ba8bd1d224499209044d40040c416d93140
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00998.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00998")
+public class BenchmarkTest00998 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie(
+                        "BenchmarkTest00998", "verifyUserPassword%28%27foo%27%2C%27bar%27%29");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest00998.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00998")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00999.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00999.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a1870d239a0a58117f634cc4467eb3ebff1c2df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest00999.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest00999")
+public class BenchmarkTest00999 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie(
+                        "BenchmarkTest00999", "verifyUserPassword%28%27foo%27%2C%27bar%27%29");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest00999.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest00999")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01000.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01000.java
new file mode 100644
index 0000000000000000000000000000000000000000..efefeda80a0df9f51bac3e655ecbd9a153c0815f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01000.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01000")
+public class BenchmarkTest01000 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie(
+                        "BenchmarkTest01000", "verifyUserPassword%28%27foo%27%2C%27bar%27%29");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01000.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01000")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01001.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01001.java
new file mode 100644
index 0000000000000000000000000000000000000000..605704253216a313be1cc7c7cd36eb26a3315bbe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01001.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01001")
+public class BenchmarkTest01001 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01001", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01001.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01001")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01002.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01002.java
new file mode 100644
index 0000000000000000000000000000000000000000..40e57edad12b44ba64eeb34fa9fbde1feacdb45e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01002.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01002")
+public class BenchmarkTest01002 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01002", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01002.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01002")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01003.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01003.java
new file mode 100644
index 0000000000000000000000000000000000000000..61e1d5e9401095c588c93a1a6771aa60a82627c0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01003.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01003")
+public class BenchmarkTest01003 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01003", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01003.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01003")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01004.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01004.java
new file mode 100644
index 0000000000000000000000000000000000000000..c62410cebc738d24b520aace6efa1531e5f80356
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01004.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01004")
+public class BenchmarkTest01004 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01004", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01004.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01004")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01005.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01005.java
new file mode 100644
index 0000000000000000000000000000000000000000..089ab9b63742fc2c025031d50f23180949b3459d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01005.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01005")
+public class BenchmarkTest01005 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01005", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01005.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01005")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01006.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01006.java
new file mode 100644
index 0000000000000000000000000000000000000000..faa0b67cbf9eaa5eb24fc25aa2d26783919a71df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01006.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01006")
+public class BenchmarkTest01006 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01006", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01006.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01006")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map36088 = new java.util.HashMap<String, Object>();
+            map36088.put("keyA-36088", "a-Value"); // put some stuff in the collection
+            map36088.put("keyB-36088", param); // put it in a collection
+            map36088.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map36088.get("keyB-36088"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01007.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01007.java
new file mode 100644
index 0000000000000000000000000000000000000000..a0a52294bfa86eb3d663371d572fa45fc42e3330
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01007.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01007")
+public class BenchmarkTest01007 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01007", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01007.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01007")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01008.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01008.java
new file mode 100644
index 0000000000000000000000000000000000000000..54ca794f810ca3d9ae449f5e59e141ff8df87614
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01008.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01008")
+public class BenchmarkTest01008 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01008", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01008.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01008")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01009.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01009.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed23e183eb319cca89736911cca12c0bc19b901d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01009.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01009")
+public class BenchmarkTest01009 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01009", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01009.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01009")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01010.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01010.java
new file mode 100644
index 0000000000000000000000000000000000000000..c13facfdd3cf74ee18e3c3efa4a5ef6e4b2c7087
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01010.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01010")
+public class BenchmarkTest01010 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01010", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01010.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01010")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01011.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01011.java
new file mode 100644
index 0000000000000000000000000000000000000000..1030300d5192bb5040334c2aeac2cf5a6796c763
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01011.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01011")
+public class BenchmarkTest01011 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01011", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01011.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01011")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01012.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01012.java
new file mode 100644
index 0000000000000000000000000000000000000000..028ece36acb2b4f59d11a1818a101fa6265e828f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01012.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01012")
+public class BenchmarkTest01012 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01012", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-02/BenchmarkTest01012.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01012")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01013.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01013.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea6eef4de10cb7070400fa3a9bdcc105abcdabdb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01013.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01013")
+public class BenchmarkTest01013 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01013", "2222");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/xpathi-00/BenchmarkTest01013.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01013")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01014.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01014.java
new file mode 100644
index 0000000000000000000000000000000000000000..fcb3780029f14b28bfdf09447a41f4c937b07881
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01014.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01014")
+public class BenchmarkTest01014 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01014", "2222");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/xpathi-00/BenchmarkTest01014.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01014")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01015.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01015.java
new file mode 100644
index 0000000000000000000000000000000000000000..b40ad355f2571e58c22e4fd913d5f529e20e3cb5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01015.java	
@@ -0,0 +1,149 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01015")
+public class BenchmarkTest01015 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01015") != null) {
+            param = request.getHeader("BenchmarkTest01015");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01016.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01016.java
new file mode 100644
index 0000000000000000000000000000000000000000..17baed7df0bcfc1fd6068e010d7d58474d5b6913
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01016.java	
@@ -0,0 +1,156 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01016")
+public class BenchmarkTest01016 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01016") != null) {
+            param = request.getHeader("BenchmarkTest01016");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map24774 = new java.util.HashMap<String, Object>();
+            map24774.put("keyA-24774", "a_Value"); // put some stuff in the collection
+            map24774.put("keyB-24774", param); // put it in a collection
+            map24774.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map24774.get("keyB-24774"); // get it back out
+            bar = (String) map24774.get("keyA-24774"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01017.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01017.java
new file mode 100644
index 0000000000000000000000000000000000000000..b111866285dc7823cf81714ab352cd8717e9ff94
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01017.java	
@@ -0,0 +1,171 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01017")
+public class BenchmarkTest01017 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01017") != null) {
+            param = request.getHeader("BenchmarkTest01017");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a27056 = param; // assign
+            StringBuilder b27056 = new StringBuilder(a27056); // stick in stringbuilder
+            b27056.append(" SafeStuff"); // append some safe content
+            b27056.replace(
+                    b27056.length() - "Chars".length(),
+                    b27056.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map27056 = new java.util.HashMap<String, Object>();
+            map27056.put("key27056", b27056.toString()); // put in a collection
+            String c27056 = (String) map27056.get("key27056"); // get it back out
+            String d27056 = c27056.substring(0, c27056.length() - 1); // extract most of it
+            String e27056 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d27056.getBytes()))); // B64 encode and decode it
+            String f27056 = e27056.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g27056 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g27056); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01018.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01018.java
new file mode 100644
index 0000000000000000000000000000000000000000..529761d63bf35e6f03d789d53b3c1c7362445d4e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01018.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01018")
+public class BenchmarkTest01018 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01018") != null) {
+            param = request.getHeader("BenchmarkTest01018");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01019.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01019.java
new file mode 100644
index 0000000000000000000000000000000000000000..82d8623a59699e127b443262d19c638783100794
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01019.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01019")
+public class BenchmarkTest01019 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01019") != null) {
+            param = request.getHeader("BenchmarkTest01019");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01020.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01020.java
new file mode 100644
index 0000000000000000000000000000000000000000..44cb896cb3586a01586703d975df829eb991d01c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01020.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01020")
+public class BenchmarkTest01020 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01020") != null) {
+            param = request.getHeader("BenchmarkTest01020");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01021.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01021.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd7d2070e47e39df72c9e4f557596e5f1838bf90
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01021.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01021")
+public class BenchmarkTest01021 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01021") != null) {
+            param = request.getHeader("BenchmarkTest01021");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map16616 = new java.util.HashMap<String, Object>();
+            map16616.put("keyA-16616", "a_Value"); // put some stuff in the collection
+            map16616.put("keyB-16616", param); // put it in a collection
+            map16616.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map16616.get("keyB-16616"); // get it back out
+            bar = (String) map16616.get("keyA-16616"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01022.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01022.java
new file mode 100644
index 0000000000000000000000000000000000000000..440f2ad66a15378799aabe3daba6e952bcaeca70
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01022.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01022")
+public class BenchmarkTest01022 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01022") != null) {
+            param = request.getHeader("BenchmarkTest01022");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01023.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01023.java
new file mode 100644
index 0000000000000000000000000000000000000000..cda8463a79ae0d8ca9059b0d0488781ad3096d2b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01023.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01023")
+public class BenchmarkTest01023 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01023") != null) {
+            param = request.getHeader("BenchmarkTest01023");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01024.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01024.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab6cb2005f1057b6eacf99c7b465787557d376f8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01024.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01024")
+public class BenchmarkTest01024 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01024") != null) {
+            param = request.getHeader("BenchmarkTest01024");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01025.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01025.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e8760053d57317ee645ca45f6d67ea21499b77f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01025.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01025")
+public class BenchmarkTest01025 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01025") != null) {
+            param = request.getHeader("BenchmarkTest01025");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01026.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01026.java
new file mode 100644
index 0000000000000000000000000000000000000000..c45d42e7b4a7ddc85e752414dfb0660906e61c18
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01026.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01026")
+public class BenchmarkTest01026 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01026") != null) {
+            param = request.getHeader("BenchmarkTest01026");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a11433 = param; // assign
+            StringBuilder b11433 = new StringBuilder(a11433); // stick in stringbuilder
+            b11433.append(" SafeStuff"); // append some safe content
+            b11433.replace(
+                    b11433.length() - "Chars".length(),
+                    b11433.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map11433 = new java.util.HashMap<String, Object>();
+            map11433.put("key11433", b11433.toString()); // put in a collection
+            String c11433 = (String) map11433.get("key11433"); // get it back out
+            String d11433 = c11433.substring(0, c11433.length() - 1); // extract most of it
+            String e11433 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d11433.getBytes()))); // B64 encode and decode it
+            String f11433 = e11433.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g11433 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g11433); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01027.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01027.java
new file mode 100644
index 0000000000000000000000000000000000000000..98af8b387066c96263f8101328fefb1d01a91462
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01027.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01027")
+public class BenchmarkTest01027 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01027") != null) {
+            param = request.getHeader("BenchmarkTest01027");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01028.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01028.java
new file mode 100644
index 0000000000000000000000000000000000000000..908845de9f3999bec5ffc801116c53e0e8fab184
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01028.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01028")
+public class BenchmarkTest01028 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01028") != null) {
+            param = request.getHeader("BenchmarkTest01028");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01029.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01029.java
new file mode 100644
index 0000000000000000000000000000000000000000..e56052f2c7cec888059fd8f6400b5ffeecf7bdd4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01029.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01029")
+public class BenchmarkTest01029 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01029") != null) {
+            param = request.getHeader("BenchmarkTest01029");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01030.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01030.java
new file mode 100644
index 0000000000000000000000000000000000000000..9cc4fc261d1236f90e8c7275779e9ee91144da40
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01030.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01030")
+public class BenchmarkTest01030 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01030") != null) {
+            param = request.getHeader("BenchmarkTest01030");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01031.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01031.java
new file mode 100644
index 0000000000000000000000000000000000000000..786e404f546ab313498b34c2ca7b1dfb63e4bbba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01031.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01031")
+public class BenchmarkTest01031 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01031") != null) {
+            param = request.getHeader("BenchmarkTest01031");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01032.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01032.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b55fa26bd13d6d479df86ee33351960e76105bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01032.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01032")
+public class BenchmarkTest01032 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01032") != null) {
+            param = request.getHeader("BenchmarkTest01032");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01033.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01033.java
new file mode 100644
index 0000000000000000000000000000000000000000..c83ab7f92bd6029655e1ba17c5a4543a7c7dac73
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01033.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01033")
+public class BenchmarkTest01033 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01033") != null) {
+            param = request.getHeader("BenchmarkTest01033");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01034.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01034.java
new file mode 100644
index 0000000000000000000000000000000000000000..a135a20fcb09f5a7ad4523a344f6759f5b63a4ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01034.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01034")
+public class BenchmarkTest01034 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01034") != null) {
+            param = request.getHeader("BenchmarkTest01034");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01035.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01035.java
new file mode 100644
index 0000000000000000000000000000000000000000..d2fb50f78007ebdd8df372d6f894a3048d074952
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01035.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01035")
+public class BenchmarkTest01035 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01035") != null) {
+            param = request.getHeader("BenchmarkTest01035");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01036.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01036.java
new file mode 100644
index 0000000000000000000000000000000000000000..89b3c14f52f7534529713699ea94b348c9bce704
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01036.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01036")
+public class BenchmarkTest01036 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01036") != null) {
+            param = request.getHeader("BenchmarkTest01036");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map8487 = new java.util.HashMap<String, Object>();
+            map8487.put("keyA-8487", "a_Value"); // put some stuff in the collection
+            map8487.put("keyB-8487", param); // put it in a collection
+            map8487.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map8487.get("keyB-8487"); // get it back out
+            bar = (String) map8487.get("keyA-8487"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01037.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01037.java
new file mode 100644
index 0000000000000000000000000000000000000000..26a0855ad7918d8a988d11f2bfe4a7ecdf9d182a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01037.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01037")
+public class BenchmarkTest01037 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01037") != null) {
+            param = request.getHeader("BenchmarkTest01037");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01038.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01038.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b785f60db9ef8e6251c1ea19218ceed35ff15b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01038.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01038")
+public class BenchmarkTest01038 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01038") != null) {
+            param = request.getHeader("BenchmarkTest01038");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01039.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01039.java
new file mode 100644
index 0000000000000000000000000000000000000000..e79c425f191f35a158a7bb925608bdccd9c081e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01039.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01039")
+public class BenchmarkTest01039 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01039") != null) {
+            param = request.getHeader("BenchmarkTest01039");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01040.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01040.java
new file mode 100644
index 0000000000000000000000000000000000000000..75fbc86a65775fdc998fae4407e15d42bf7ecad1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01040.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01040")
+public class BenchmarkTest01040 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01040") != null) {
+            param = request.getHeader("BenchmarkTest01040");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz96551 = new StringBuilder(param);
+            String bar = sbxyz96551.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01041.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01041.java
new file mode 100644
index 0000000000000000000000000000000000000000..fdf08652e0d49dca4a725c1c2c80c3ae76ff0f0b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01041.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01041")
+public class BenchmarkTest01041 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01041") != null) {
+            param = request.getHeader("BenchmarkTest01041");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01042.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01042.java
new file mode 100644
index 0000000000000000000000000000000000000000..eddb43d7f109cdbd58fd26fca68d44a4c03d27e4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01042.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01042")
+public class BenchmarkTest01042 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01042") != null) {
+            param = request.getHeader("BenchmarkTest01042");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz89642 = new StringBuilder(param);
+            String bar = sbxyz89642.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01043.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01043.java
new file mode 100644
index 0000000000000000000000000000000000000000..3655146381c79ead8dac14e3307a37e1742c7bf9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01043.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01043")
+public class BenchmarkTest01043 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01043") != null) {
+            param = request.getHeader("BenchmarkTest01043");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01044.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01044.java
new file mode 100644
index 0000000000000000000000000000000000000000..308b5befafdff8c9bbf56f46d8c206f7e44d40b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01044.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01044")
+public class BenchmarkTest01044 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01044") != null) {
+            param = request.getHeader("BenchmarkTest01044");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01045.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01045.java
new file mode 100644
index 0000000000000000000000000000000000000000..685a2919abe97d8dc2d6220b9dee16cdba7c4713
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01045.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01045")
+public class BenchmarkTest01045 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01045") != null) {
+            param = request.getHeader("BenchmarkTest01045");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01046.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01046.java
new file mode 100644
index 0000000000000000000000000000000000000000..5085a5c06c8082c364eea4544ba68a97158a4546
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01046.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest01046")
+public class BenchmarkTest01046 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map95803 = new java.util.HashMap<String, Object>();
+            map95803.put("keyA-95803", "a-Value"); // put some stuff in the collection
+            map95803.put("keyB-95803", param); // put it in a collection
+            map95803.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map95803.get("keyB-95803"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01047.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01047.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a8a22e44adaeb7fe74e7d88c38fbe5ad9393136
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01047.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-01/BenchmarkTest01047")
+public class BenchmarkTest01047 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz50709 = new StringBuilder(param);
+                bar =
+                        sbxyz50709
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01048.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01048.java
new file mode 100644
index 0000000000000000000000000000000000000000..796154352d86b7ea323a6e8d185af3081bfc734d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01048.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01048")
+public class BenchmarkTest01048 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01049.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01049.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8aa856fb1391ed2ee0a661c4935e2bab72fe28d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01049.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01049")
+public class BenchmarkTest01049 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01050.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01050.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d1e602df24dc9d4a4aba426baac7abe003b8d99
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01050.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01050")
+public class BenchmarkTest01050 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz75528 = new StringBuilder(param);
+            String bar = sbxyz75528.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01051.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01051.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd4af507caa27fe34999008057c05ffcbfc3b0f7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01051.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01051")
+public class BenchmarkTest01051 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01052.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01052.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8b74a892c60873534aa642a5c17e8417e60ba17
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01052.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01052")
+public class BenchmarkTest01052 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01053.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01053.java
new file mode 100644
index 0000000000000000000000000000000000000000..83a6dc4095fe8d8e18c6c2016203b4ba9d5ac602
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01053.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01053")
+public class BenchmarkTest01053 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01054.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01054.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8c88561df33c55ddeeefa213c2e34838e9e17ae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01054.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01054")
+public class BenchmarkTest01054 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01055.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01055.java
new file mode 100644
index 0000000000000000000000000000000000000000..2598f7923d049176df078ba9c5febb32053d61c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01055.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01055")
+public class BenchmarkTest01055 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01056.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01056.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b37d840af99c53efa7cbc0a48be713b16d27665
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01056.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01056")
+public class BenchmarkTest01056 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01057.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01057.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae84219001607bba58224bac65a3e4059af33d10
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01057.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01057")
+public class BenchmarkTest01057 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01058.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01058.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d391b8b4d42628185e8bd8909d2c7ba5dc16d8c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01058.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01058")
+public class BenchmarkTest01058 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01058") != null) {
+            param = request.getHeader("BenchmarkTest01058");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz56505 = new StringBuilder(param);
+            String bar = sbxyz56505.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01059.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01059.java
new file mode 100644
index 0000000000000000000000000000000000000000..d909553d0690e7c8780597885c1eb146d39e0220
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01059.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01059")
+public class BenchmarkTest01059 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01059") != null) {
+            param = request.getHeader("BenchmarkTest01059");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01060.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01060.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccb5cce5ec29e396e758cc495ca7148c35280f9d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01060.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01060")
+public class BenchmarkTest01060 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01060") != null) {
+            param = request.getHeader("BenchmarkTest01060");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01061.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01061.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb4e4385b9d1b4cfe8f6e8fa0f451c2c29cbd00c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01061.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01061")
+public class BenchmarkTest01061 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01061") != null) {
+            param = request.getHeader("BenchmarkTest01061");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz37461 = new StringBuilder(param);
+                bar =
+                        sbxyz37461
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01062.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01062.java
new file mode 100644
index 0000000000000000000000000000000000000000..db8a7081d007a24573575293e3b191cfa546c44b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01062.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01062")
+public class BenchmarkTest01062 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01062") != null) {
+            param = request.getHeader("BenchmarkTest01062");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01063.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01063.java
new file mode 100644
index 0000000000000000000000000000000000000000..58a99f6f9b9c0cf8b440016803f3cf93139a4717
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01063.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01063")
+public class BenchmarkTest01063 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a92400 = param; // assign
+            StringBuilder b92400 = new StringBuilder(a92400); // stick in stringbuilder
+            b92400.append(" SafeStuff"); // append some safe content
+            b92400.replace(
+                    b92400.length() - "Chars".length(),
+                    b92400.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map92400 = new java.util.HashMap<String, Object>();
+            map92400.put("key92400", b92400.toString()); // put in a collection
+            String c92400 = (String) map92400.get("key92400"); // get it back out
+            String d92400 = c92400.substring(0, c92400.length() - 1); // extract most of it
+            String e92400 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d92400.getBytes()))); // B64 encode and decode it
+            String f92400 = e92400.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f92400); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01064.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01064.java
new file mode 100644
index 0000000000000000000000000000000000000000..6124f24358ad5292293c0b08e68b2ba0cf1c9feb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01064.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01064")
+public class BenchmarkTest01064 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01064") != null) {
+            param = request.getHeader("BenchmarkTest01064");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map72463 = new java.util.HashMap<String, Object>();
+            map72463.put("keyA-72463", "a-Value"); // put some stuff in the collection
+            map72463.put("keyB-72463", param); // put it in a collection
+            map72463.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map72463.get("keyB-72463"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01065.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01065.java
new file mode 100644
index 0000000000000000000000000000000000000000..9516e6caf4db5899f3ad31c334abfb27a3d170f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01065.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01065")
+public class BenchmarkTest01065 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01065") != null) {
+            param = request.getHeader("BenchmarkTest01065");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01066.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01066.java
new file mode 100644
index 0000000000000000000000000000000000000000..a778035e5367ae4506e456ab3a2339ca41a475a0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01066.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01066")
+public class BenchmarkTest01066 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01066") != null) {
+            param = request.getHeader("BenchmarkTest01066");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01067.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01067.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba97d0d0fb44db834e94f7d412d48f9e1a1efc9f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01067.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01067")
+public class BenchmarkTest01067 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01067") != null) {
+            param = request.getHeader("BenchmarkTest01067");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01068.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01068.java
new file mode 100644
index 0000000000000000000000000000000000000000..71a7435b2a410bc910a24f0fd5e29dd8da4a1881
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01068.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01068")
+public class BenchmarkTest01068 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01068") != null) {
+            param = request.getHeader("BenchmarkTest01068");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01069.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01069.java
new file mode 100644
index 0000000000000000000000000000000000000000..354c6375b51cb547f1307965df5df5d9b99c5636
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01069.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01069")
+public class BenchmarkTest01069 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01069") != null) {
+            param = request.getHeader("BenchmarkTest01069");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01070.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01070.java
new file mode 100644
index 0000000000000000000000000000000000000000..75847b3d11a89d386998ad90b0e77aa4a576c332
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01070.java	
@@ -0,0 +1,132 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01070")
+public class BenchmarkTest01070 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01070") != null) {
+            param = request.getHeader("BenchmarkTest01070");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a85812 = param; // assign
+            StringBuilder b85812 = new StringBuilder(a85812); // stick in stringbuilder
+            b85812.append(" SafeStuff"); // append some safe content
+            b85812.replace(
+                    b85812.length() - "Chars".length(),
+                    b85812.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map85812 = new java.util.HashMap<String, Object>();
+            map85812.put("key85812", b85812.toString()); // put in a collection
+            String c85812 = (String) map85812.get("key85812"); // get it back out
+            String d85812 = c85812.substring(0, c85812.length() - 1); // extract most of it
+            String e85812 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d85812.getBytes()))); // B64 encode and decode it
+            String f85812 = e85812.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f85812); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01071.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01071.java
new file mode 100644
index 0000000000000000000000000000000000000000..cdfc63b0cf2ae8c597bb348ee94ebef4e789c057
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01071.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01071")
+public class BenchmarkTest01071 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01071") != null) {
+            param = request.getHeader("BenchmarkTest01071");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01072.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01072.java
new file mode 100644
index 0000000000000000000000000000000000000000..823bc0191457c162ebaab3bca54ea0638538fe18
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01072.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01072")
+public class BenchmarkTest01072 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01072") != null) {
+            param = request.getHeader("BenchmarkTest01072");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01073.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01073.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e780eee5cc56c2ce9badcf068984b9b0dab23f3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01073.java	
@@ -0,0 +1,128 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01073")
+public class BenchmarkTest01073 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01073") != null) {
+            param = request.getHeader("BenchmarkTest01073");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01074.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01074.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf954f3efe63716fda031220c21a00cf099dea70
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01074.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01074")
+public class BenchmarkTest01074 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01074") != null) {
+            param = request.getHeader("BenchmarkTest01074");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01075.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01075.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb6826100d70011700b8472b70aedfebc956351f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01075.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01075")
+public class BenchmarkTest01075 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01075") != null) {
+            param = request.getHeader("BenchmarkTest01075");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01076.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01076.java
new file mode 100644
index 0000000000000000000000000000000000000000..a214257b755f614aff3f869297fefa925be38b32
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01076.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01076")
+public class BenchmarkTest01076 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01076") != null) {
+            param = request.getHeader("BenchmarkTest01076");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01077.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01077.java
new file mode 100644
index 0000000000000000000000000000000000000000..380d6464e9edd99a26411a07a0a7ac42ff2ae01b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01077.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01077")
+public class BenchmarkTest01077 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01077") != null) {
+            param = request.getHeader("BenchmarkTest01077");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01078.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01078.java
new file mode 100644
index 0000000000000000000000000000000000000000..19f7b79d6c2fc696a5b15a7e101548a06cae807a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01078.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01078")
+public class BenchmarkTest01078 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01078") != null) {
+            param = request.getHeader("BenchmarkTest01078");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz97831 = new StringBuilder(param);
+            String bar = sbxyz97831.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01079.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01079.java
new file mode 100644
index 0000000000000000000000000000000000000000..233e755ba16d15579f241ce3d764d4da125808fb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01079.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01079")
+public class BenchmarkTest01079 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01079") != null) {
+            param = request.getHeader("BenchmarkTest01079");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01080.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01080.java
new file mode 100644
index 0000000000000000000000000000000000000000..2365e9c6a708fb6c6b2f2f9cc5e96a89c9f46dad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01080.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01080")
+public class BenchmarkTest01080 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01080") != null) {
+            param = request.getHeader("BenchmarkTest01080");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01081.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01081.java
new file mode 100644
index 0000000000000000000000000000000000000000..29646671bee48518cf8c302dabce3bbaf13892be
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01081.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01081")
+public class BenchmarkTest01081 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01081") != null) {
+            param = request.getHeader("BenchmarkTest01081");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz55141 = new StringBuilder(param);
+            String bar = sbxyz55141.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01082.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01082.java
new file mode 100644
index 0000000000000000000000000000000000000000..19000933c6431578f6eaf125e6acdbd239a54675
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01082.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01082")
+public class BenchmarkTest01082 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01082") != null) {
+            param = request.getHeader("BenchmarkTest01082");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01083.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01083.java
new file mode 100644
index 0000000000000000000000000000000000000000..1141a5cb74d96a0b0b0650c2782f00d659f640b4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01083.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01083")
+public class BenchmarkTest01083 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01083") != null) {
+            param = request.getHeader("BenchmarkTest01083");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01084.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01084.java
new file mode 100644
index 0000000000000000000000000000000000000000..cdd9bd7239e268a453b84bfc424369f5cf4f5cfd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01084.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01084")
+public class BenchmarkTest01084 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01084") != null) {
+            param = request.getHeader("BenchmarkTest01084");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01085.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01085.java
new file mode 100644
index 0000000000000000000000000000000000000000..823847daa7d84376b796aeb1ac6c48211a02a277
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01085.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01085")
+public class BenchmarkTest01085 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01085") != null) {
+            param = request.getHeader("BenchmarkTest01085");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01086.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01086.java
new file mode 100644
index 0000000000000000000000000000000000000000..6aaa60faec09e0e728755105f11f566902826c35
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01086.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01086")
+public class BenchmarkTest01086 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01086") != null) {
+            param = request.getHeader("BenchmarkTest01086");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01087.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01087.java
new file mode 100644
index 0000000000000000000000000000000000000000..a52e83b32d07b0e5efab2107e98b3cccab78c1cb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01087.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01087")
+public class BenchmarkTest01087 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01087") != null) {
+            param = request.getHeader("BenchmarkTest01087");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01088.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01088.java
new file mode 100644
index 0000000000000000000000000000000000000000..e672b09337d338381947bf0c715262d7e8d70e04
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01088.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01088")
+public class BenchmarkTest01088 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01088") != null) {
+            param = request.getHeader("BenchmarkTest01088");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01089.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01089.java
new file mode 100644
index 0000000000000000000000000000000000000000..2176c1a40fb9c0b69919007c6be13e56daac27ad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01089.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01089")
+public class BenchmarkTest01089 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01089") != null) {
+            param = request.getHeader("BenchmarkTest01089");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map11607 = new java.util.HashMap<String, Object>();
+            map11607.put("keyA-11607", "a_Value"); // put some stuff in the collection
+            map11607.put("keyB-11607", param); // put it in a collection
+            map11607.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map11607.get("keyB-11607"); // get it back out
+            bar = (String) map11607.get("keyA-11607"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01090.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01090.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ed9fd1a7ca7a6896e91eb5adb26ae3bab91887d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01090.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01090")
+public class BenchmarkTest01090 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01090") != null) {
+            param = request.getHeader("BenchmarkTest01090");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map12212 = new java.util.HashMap<String, Object>();
+            map12212.put("keyA-12212", "a-Value"); // put some stuff in the collection
+            map12212.put("keyB-12212", param); // put it in a collection
+            map12212.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map12212.get("keyB-12212"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01091.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01091.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3df8459954dc889fb5722917197f4b784d1cbb2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01091.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01091")
+public class BenchmarkTest01091 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01091") != null) {
+            param = request.getHeader("BenchmarkTest01091");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01092.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01092.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef353a5b0f97254e65015ed43b154949f5158bfb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01092.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01092")
+public class BenchmarkTest01092 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01092") != null) {
+            param = request.getHeader("BenchmarkTest01092");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01093.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01093.java
new file mode 100644
index 0000000000000000000000000000000000000000..97ec59ce49c3fa9b24c1ddd2489ceae2130b7c38
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01093.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01093")
+public class BenchmarkTest01093 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01093") != null) {
+            param = request.getHeader("BenchmarkTest01093");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map18142 = new java.util.HashMap<String, Object>();
+            map18142.put("keyA-18142", "a-Value"); // put some stuff in the collection
+            map18142.put("keyB-18142", param); // put it in a collection
+            map18142.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map18142.get("keyB-18142"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01094.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01094.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c08469715e0f387a9c384b549697cd5778e886e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01094.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01094")
+public class BenchmarkTest01094 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01094") != null) {
+            param = request.getHeader("BenchmarkTest01094");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01095.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01095.java
new file mode 100644
index 0000000000000000000000000000000000000000..44ebe5bfa283f2ecdd63f5d82ea0f226268594cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01095.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01095")
+public class BenchmarkTest01095 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01095") != null) {
+            param = request.getHeader("BenchmarkTest01095");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01096.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01096.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d27cbd0eec1b1abdcb60af449cc68964ff93d62
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01096.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01096")
+public class BenchmarkTest01096 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01096") != null) {
+            param = request.getHeader("BenchmarkTest01096");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01097.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01097.java
new file mode 100644
index 0000000000000000000000000000000000000000..81e95d920f6b01ed08877b2ef773bbc33daf5fa4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01097.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01097")
+public class BenchmarkTest01097 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01097") != null) {
+            param = request.getHeader("BenchmarkTest01097");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01098.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01098.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb875fdd5aa45351c034118cb9a10ddb25fcad1b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01098.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01098")
+public class BenchmarkTest01098 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01098") != null) {
+            param = request.getHeader("BenchmarkTest01098");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01099.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01099.java
new file mode 100644
index 0000000000000000000000000000000000000000..e321a45ea569df0502725176037c596c16528f6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01099.java	
@@ -0,0 +1,162 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01099")
+public class BenchmarkTest01099 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map30744 = new java.util.HashMap<String, Object>();
+            map30744.put("keyA-30744", "a_Value"); // put some stuff in the collection
+            map30744.put("keyB-30744", param); // put it in a collection
+            map30744.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map30744.get("keyB-30744"); // get it back out
+            bar = (String) map30744.get("keyA-30744"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01100.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01100.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e6be54a7f4ecb28b6baed84f3455b7c548c14ea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01100.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01100")
+public class BenchmarkTest01100 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz90035 = new StringBuilder(param);
+                bar =
+                        sbxyz90035
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01101.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01101.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a583fc991329004385745f077baba8bae510c49
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01101.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01101")
+public class BenchmarkTest01101 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01102.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01102.java
new file mode 100644
index 0000000000000000000000000000000000000000..0eef4d9e78e2e7d03469ffa938b59803efae8724
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01102.java	
@@ -0,0 +1,131 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01102")
+public class BenchmarkTest01102 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map10086 = new java.util.HashMap<String, Object>();
+            map10086.put("keyA-10086", "a-Value"); // put some stuff in the collection
+            map10086.put("keyB-10086", param); // put it in a collection
+            map10086.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map10086.get("keyB-10086"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01103.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01103.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd2a0aaa9090c1b016bee5e08b6667673abdf271
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01103.java	
@@ -0,0 +1,145 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01103")
+public class BenchmarkTest01103 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01104.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01104.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f18d3c977e85101e11b9fc0dfce3c6bec79bffe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01104.java	
@@ -0,0 +1,137 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01104")
+public class BenchmarkTest01104 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01105.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01105.java
new file mode 100644
index 0000000000000000000000000000000000000000..afb460c2d620dac66f72bee3b604d2d07ded4a90
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01105.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01105")
+public class BenchmarkTest01105 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01106.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01106.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd57512b604832780d28e52548c7988dc79b14b4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01106.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01106")
+public class BenchmarkTest01106 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01107.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01107.java
new file mode 100644
index 0000000000000000000000000000000000000000..37fa4576395e7a9da19802088c751ff4f805a018
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01107.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01107")
+public class BenchmarkTest01107 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01108.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01108.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d4d37ddad3e6c8e4f51c5034451a1ae714ae493
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01108.java	
@@ -0,0 +1,134 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01108")
+public class BenchmarkTest01108 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01109.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01109.java
new file mode 100644
index 0000000000000000000000000000000000000000..c20c63f88976b21fa987440b2e55500aa59235ce
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01109.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01109")
+public class BenchmarkTest01109 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a87030 = param; // assign
+            StringBuilder b87030 = new StringBuilder(a87030); // stick in stringbuilder
+            b87030.append(" SafeStuff"); // append some safe content
+            b87030.replace(
+                    b87030.length() - "Chars".length(),
+                    b87030.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map87030 = new java.util.HashMap<String, Object>();
+            map87030.put("key87030", b87030.toString()); // put in a collection
+            String c87030 = (String) map87030.get("key87030"); // get it back out
+            String d87030 = c87030.substring(0, c87030.length() - 1); // extract most of it
+            String e87030 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d87030.getBytes()))); // B64 encode and decode it
+            String f87030 = e87030.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g87030 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g87030); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01110.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01110.java
new file mode 100644
index 0000000000000000000000000000000000000000..d60da79e971da6cd0e9b174483f9df86904b0c75
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01110.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01110")
+public class BenchmarkTest01110 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01111.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01111.java
new file mode 100644
index 0000000000000000000000000000000000000000..ca482306594e5db440d313c67d4fa9b048185a81
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01111.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01111")
+public class BenchmarkTest01111 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01112.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01112.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f9eacb46e66611798b216f85aa4b1cd675f504a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01112.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01112")
+public class BenchmarkTest01112 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01113.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01113.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6b28fb39b28867fb49c3e4c3be5e64dd35efef5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01113.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01113")
+public class BenchmarkTest01113 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map50384 = new java.util.HashMap<String, Object>();
+            map50384.put("keyA-50384", "a_Value"); // put some stuff in the collection
+            map50384.put("keyB-50384", param); // put it in a collection
+            map50384.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map50384.get("keyB-50384"); // get it back out
+            bar = (String) map50384.get("keyA-50384"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01114.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01114.java
new file mode 100644
index 0000000000000000000000000000000000000000..56b52a0c025e5b15acad048b3f71c57f08de00e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01114.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01114")
+public class BenchmarkTest01114 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a97099 = param; // assign
+            StringBuilder b97099 = new StringBuilder(a97099); // stick in stringbuilder
+            b97099.append(" SafeStuff"); // append some safe content
+            b97099.replace(
+                    b97099.length() - "Chars".length(),
+                    b97099.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map97099 = new java.util.HashMap<String, Object>();
+            map97099.put("key97099", b97099.toString()); // put in a collection
+            String c97099 = (String) map97099.get("key97099"); // get it back out
+            String d97099 = c97099.substring(0, c97099.length() - 1); // extract most of it
+            String e97099 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d97099.getBytes()))); // B64 encode and decode it
+            String f97099 = e97099.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g97099 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g97099); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01115.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01115.java
new file mode 100644
index 0000000000000000000000000000000000000000..f654d2e16a7374b694521a6fa0089fe8d1fc1660
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01115.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01115")
+public class BenchmarkTest01115 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a43762 = param; // assign
+            StringBuilder b43762 = new StringBuilder(a43762); // stick in stringbuilder
+            b43762.append(" SafeStuff"); // append some safe content
+            b43762.replace(
+                    b43762.length() - "Chars".length(),
+                    b43762.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map43762 = new java.util.HashMap<String, Object>();
+            map43762.put("key43762", b43762.toString()); // put in a collection
+            String c43762 = (String) map43762.get("key43762"); // get it back out
+            String d43762 = c43762.substring(0, c43762.length() - 1); // extract most of it
+            String e43762 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d43762.getBytes()))); // B64 encode and decode it
+            String f43762 = e43762.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g43762 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g43762); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01116.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01116.java
new file mode 100644
index 0000000000000000000000000000000000000000..64adff540384fbedfe0e06f6d1d92196051ce5d9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01116.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01116")
+public class BenchmarkTest01116 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01117.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01117.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ba9b122c5e269bc0e63f12f075d736c724b5491
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01117.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01117")
+public class BenchmarkTest01117 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01118.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01118.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed500213d7929c7acbe743755caf87f85b75991b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01118.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01118")
+public class BenchmarkTest01118 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map63904 = new java.util.HashMap<String, Object>();
+            map63904.put("keyA-63904", "a_Value"); // put some stuff in the collection
+            map63904.put("keyB-63904", param); // put it in a collection
+            map63904.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map63904.get("keyB-63904"); // get it back out
+            bar = (String) map63904.get("keyA-63904"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01119.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01119.java
new file mode 100644
index 0000000000000000000000000000000000000000..7914495309f15053f8f564f04c5616d9607bb7d7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01119.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01119")
+public class BenchmarkTest01119 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01120.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01120.java
new file mode 100644
index 0000000000000000000000000000000000000000..521e587a267ec738c781b0f1fb74951ec8b3aa00
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01120.java	
@@ -0,0 +1,138 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01120")
+public class BenchmarkTest01120 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a99915 = param; // assign
+            StringBuilder b99915 = new StringBuilder(a99915); // stick in stringbuilder
+            b99915.append(" SafeStuff"); // append some safe content
+            b99915.replace(
+                    b99915.length() - "Chars".length(),
+                    b99915.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map99915 = new java.util.HashMap<String, Object>();
+            map99915.put("key99915", b99915.toString()); // put in a collection
+            String c99915 = (String) map99915.get("key99915"); // get it back out
+            String d99915 = c99915.substring(0, c99915.length() - 1); // extract most of it
+            String e99915 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d99915.getBytes()))); // B64 encode and decode it
+            String f99915 = e99915.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f99915); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01121.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01121.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ff774266a52f1145b4592dd88aa9b5368d24e9c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01121.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01121")
+public class BenchmarkTest01121 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz22801 = new StringBuilder(param);
+            String bar = sbxyz22801.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01122.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01122.java
new file mode 100644
index 0000000000000000000000000000000000000000..905c6ce108e33793d498d5b52511f7020392e6e4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01122.java	
@@ -0,0 +1,137 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01122")
+public class BenchmarkTest01122 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01123.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01123.java
new file mode 100644
index 0000000000000000000000000000000000000000..7885f40fe7597b3dd88de057e6a127977b8d1d1a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01123.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01123")
+public class BenchmarkTest01123 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01124.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01124.java
new file mode 100644
index 0000000000000000000000000000000000000000..f3b4fcb43944697d99860d8be52c70be431bd10e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01124.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01124")
+public class BenchmarkTest01124 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map74702 = new java.util.HashMap<String, Object>();
+            map74702.put("keyA-74702", "a_Value"); // put some stuff in the collection
+            map74702.put("keyB-74702", param); // put it in a collection
+            map74702.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map74702.get("keyB-74702"); // get it back out
+            bar = (String) map74702.get("keyA-74702"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01125.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01125.java
new file mode 100644
index 0000000000000000000000000000000000000000..78c98364fa425f3df5ea7b16f1e09f6c1d100bd6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01125.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01125")
+public class BenchmarkTest01125 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01126.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01126.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e803ab9074ba5d6e5cfe51d82fc6b6d1a401b13
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01126.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01126")
+public class BenchmarkTest01126 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01127.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01127.java
new file mode 100644
index 0000000000000000000000000000000000000000..053263bbc29b3987afa61919e9f3482adb297821
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01127.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01127")
+public class BenchmarkTest01127 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01128.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01128.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3170f560b6f7430d1fba99ce7ef2718fcf7e0a2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01128.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01128")
+public class BenchmarkTest01128 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz90224 = new StringBuilder(param);
+                bar =
+                        sbxyz90224
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01129.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01129.java
new file mode 100644
index 0000000000000000000000000000000000000000..02f6f82b1878c6f476f5e037b138654ea7e22ff7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01129.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01129")
+public class BenchmarkTest01129 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01130.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01130.java
new file mode 100644
index 0000000000000000000000000000000000000000..41f975bb10a12aa7e5ff54b241042e1863878f08
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01130.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01130")
+public class BenchmarkTest01130 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01131.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01131.java
new file mode 100644
index 0000000000000000000000000000000000000000..59b79ec8a3bf8903f3f51355dfaeec29acc28db0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01131.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01131")
+public class BenchmarkTest01131 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01132.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01132.java
new file mode 100644
index 0000000000000000000000000000000000000000..692870cfac8b49cb8eae96a7c4911f4a95805da0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01132.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01132")
+public class BenchmarkTest01132 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01133.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01133.java
new file mode 100644
index 0000000000000000000000000000000000000000..49fade5395588ee2729a89c117c67b853b492136
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01133.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01133")
+public class BenchmarkTest01133 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01134.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01134.java
new file mode 100644
index 0000000000000000000000000000000000000000..285c445b65cb1f740020538d623ad46ebac16aba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01134.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01134")
+public class BenchmarkTest01134 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map9728 = new java.util.HashMap<String, Object>();
+            map9728.put("keyA-9728", "a-Value"); // put some stuff in the collection
+            map9728.put("keyB-9728", param); // put it in a collection
+            map9728.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map9728.get("keyB-9728"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01135.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01135.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c5c7f5f9131b5e831eaf890ed9f34d542fa7739
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01135.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01135")
+public class BenchmarkTest01135 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01136.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01136.java
new file mode 100644
index 0000000000000000000000000000000000000000..427172b91da40f6a6305cae136e55522908d0a00
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01136.java	
@@ -0,0 +1,140 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01136")
+public class BenchmarkTest01136 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a58606 = param; // assign
+            StringBuilder b58606 = new StringBuilder(a58606); // stick in stringbuilder
+            b58606.append(" SafeStuff"); // append some safe content
+            b58606.replace(
+                    b58606.length() - "Chars".length(),
+                    b58606.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map58606 = new java.util.HashMap<String, Object>();
+            map58606.put("key58606", b58606.toString()); // put in a collection
+            String c58606 = (String) map58606.get("key58606"); // get it back out
+            String d58606 = c58606.substring(0, c58606.length() - 1); // extract most of it
+            String e58606 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d58606.getBytes()))); // B64 encode and decode it
+            String f58606 = e58606.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g58606 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g58606); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01137.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01137.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8ff3f015c00085b728c169e9193114c6767904b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01137.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01137")
+public class BenchmarkTest01137 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz8314 = new StringBuilder(param);
+            String bar = sbxyz8314.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01138.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01138.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ca7e4157c2b0a8bfd4c5ed592f7eb307b6920d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01138.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01138")
+public class BenchmarkTest01138 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz47470 = new StringBuilder(param);
+                bar =
+                        sbxyz47470
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01139.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01139.java
new file mode 100644
index 0000000000000000000000000000000000000000..dedec039748f09802997477d0137d382a28d11c1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01139.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01139")
+public class BenchmarkTest01139 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz40917 = new StringBuilder(param);
+                bar =
+                        sbxyz40917
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01140.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01140.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c10f3c558de5f5120ec6e929c001871c4f497ed
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01140.java	
@@ -0,0 +1,131 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01140")
+public class BenchmarkTest01140 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a25760 = param; // assign
+            StringBuilder b25760 = new StringBuilder(a25760); // stick in stringbuilder
+            b25760.append(" SafeStuff"); // append some safe content
+            b25760.replace(
+                    b25760.length() - "Chars".length(),
+                    b25760.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map25760 = new java.util.HashMap<String, Object>();
+            map25760.put("key25760", b25760.toString()); // put in a collection
+            String c25760 = (String) map25760.get("key25760"); // get it back out
+            String d25760 = c25760.substring(0, c25760.length() - 1); // extract most of it
+            String e25760 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d25760.getBytes()))); // B64 encode and decode it
+            String f25760 = e25760.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g25760 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g25760); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01141.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01141.java
new file mode 100644
index 0000000000000000000000000000000000000000..2421ed292a6d0918729d2a6d5a5e6f05f408360a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01141.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01141")
+public class BenchmarkTest01141 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz2940 = new StringBuilder(param);
+                bar =
+                        sbxyz2940
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01142.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01142.java
new file mode 100644
index 0000000000000000000000000000000000000000..568f1a6daaed7cf6eec336a3890c404456c40797
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01142.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01142")
+public class BenchmarkTest01142 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01143.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01143.java
new file mode 100644
index 0000000000000000000000000000000000000000..92577f7081a55ca2ac0772a66bfbdd0ca02ae969
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01143.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01143")
+public class BenchmarkTest01143 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz70712 = new StringBuilder(param);
+            String bar = sbxyz70712.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01144.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01144.java
new file mode 100644
index 0000000000000000000000000000000000000000..c859a9657c05f1fe69fbd709f5a0ae1d388b0a91
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01144.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01144")
+public class BenchmarkTest01144 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01145.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01145.java
new file mode 100644
index 0000000000000000000000000000000000000000..65e73d7ea71d796451e3fb067f57209aa659e04a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01145.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01145")
+public class BenchmarkTest01145 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01146.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01146.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ea380e68c7c9f32e870e02b808d202699f16cb1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01146.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01146")
+public class BenchmarkTest01146 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01147.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01147.java
new file mode 100644
index 0000000000000000000000000000000000000000..997d1614386efb160dc5b97b32cd7302ccc91baa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01147.java	
@@ -0,0 +1,156 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01147")
+public class BenchmarkTest01147 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01147");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz71288 = new StringBuilder(param);
+                bar =
+                        sbxyz71288
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01148.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01148.java
new file mode 100644
index 0000000000000000000000000000000000000000..43a38c179625164f57a4160d762f9b064b85ade7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01148.java	
@@ -0,0 +1,157 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01148")
+public class BenchmarkTest01148 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01148");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01149.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01149.java
new file mode 100644
index 0000000000000000000000000000000000000000..a6cb5a0a68f1302599473d1dc4fc93faa6986c15
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01149.java	
@@ -0,0 +1,171 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01149")
+public class BenchmarkTest01149 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01149");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01150.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01150.java
new file mode 100644
index 0000000000000000000000000000000000000000..2123b73ad762e61f49ec32f584e038b6cd6e68ff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01150.java	
@@ -0,0 +1,128 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01150")
+public class BenchmarkTest01150 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01150");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01151.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01151.java
new file mode 100644
index 0000000000000000000000000000000000000000..68934ee43b75229479bbfb15667aaa19e39fb400
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01151.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01151")
+public class BenchmarkTest01151 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01151");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01152.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01152.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a35909b53b6ed2a068218ae449028cc38f2c23f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01152.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01152")
+public class BenchmarkTest01152 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01152");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01153.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01153.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc651ae237f0e3b4b367f8fd727e05e770345f01
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01153.java	
@@ -0,0 +1,140 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01153")
+public class BenchmarkTest01153 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01153");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a2387 = param; // assign
+            StringBuilder b2387 = new StringBuilder(a2387); // stick in stringbuilder
+            b2387.append(" SafeStuff"); // append some safe content
+            b2387.replace(
+                    b2387.length() - "Chars".length(),
+                    b2387.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map2387 = new java.util.HashMap<String, Object>();
+            map2387.put("key2387", b2387.toString()); // put in a collection
+            String c2387 = (String) map2387.get("key2387"); // get it back out
+            String d2387 = c2387.substring(0, c2387.length() - 1); // extract most of it
+            String e2387 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d2387.getBytes()))); // B64 encode and decode it
+            String f2387 = e2387.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g2387 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g2387); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01154.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01154.java
new file mode 100644
index 0000000000000000000000000000000000000000..31918a803302da6ce355507f048b8529dd371a2c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01154.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01154")
+public class BenchmarkTest01154 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01154");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01155.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01155.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e28966deaa37ddb3b5ec6a680da3eea8526706b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01155.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01155")
+public class BenchmarkTest01155 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01155");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01156.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01156.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a73890a1713915cd3bfd4aaf98821d41d0fe3b5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01156.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01156")
+public class BenchmarkTest01156 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01156");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map55476 = new java.util.HashMap<String, Object>();
+            map55476.put("keyA-55476", "a-Value"); // put some stuff in the collection
+            map55476.put("keyB-55476", param); // put it in a collection
+            map55476.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map55476.get("keyB-55476"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01157.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01157.java
new file mode 100644
index 0000000000000000000000000000000000000000..53450dc5fbad4fd2fe3cdafc56fc2fa62b6063be
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01157.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01157")
+public class BenchmarkTest01157 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01157");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01158.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01158.java
new file mode 100644
index 0000000000000000000000000000000000000000..44b67a4151378388f6d4852c869164dea339c449
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01158.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01158")
+public class BenchmarkTest01158 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01158");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01159.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01159.java
new file mode 100644
index 0000000000000000000000000000000000000000..129a83da18f0f8a1aac430e1ede37374f515dd02
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01159.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01159")
+public class BenchmarkTest01159 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01159");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a54259 = param; // assign
+            StringBuilder b54259 = new StringBuilder(a54259); // stick in stringbuilder
+            b54259.append(" SafeStuff"); // append some safe content
+            b54259.replace(
+                    b54259.length() - "Chars".length(),
+                    b54259.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map54259 = new java.util.HashMap<String, Object>();
+            map54259.put("key54259", b54259.toString()); // put in a collection
+            String c54259 = (String) map54259.get("key54259"); // get it back out
+            String d54259 = c54259.substring(0, c54259.length() - 1); // extract most of it
+            String e54259 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d54259.getBytes()))); // B64 encode and decode it
+            String f54259 = e54259.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g54259 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g54259); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01160.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01160.java
new file mode 100644
index 0000000000000000000000000000000000000000..f55175b6529d8831d620508dfc17d381b6b96a24
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01160.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01160")
+public class BenchmarkTest01160 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01160");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01161.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01161.java
new file mode 100644
index 0000000000000000000000000000000000000000..58e35cdc2b1b509e0f91492ef35505e40c37acd0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01161.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01161")
+public class BenchmarkTest01161 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01161");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01162.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01162.java
new file mode 100644
index 0000000000000000000000000000000000000000..3831d705eb31023770105a98e83d00ed762f8027
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01162.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01162")
+public class BenchmarkTest01162 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01162");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map72162 = new java.util.HashMap<String, Object>();
+            map72162.put("keyA-72162", "a_Value"); // put some stuff in the collection
+            map72162.put("keyB-72162", param); // put it in a collection
+            map72162.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map72162.get("keyB-72162"); // get it back out
+            bar = (String) map72162.get("keyA-72162"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01163.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01163.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d98c84ffcbe8f307d7451095622aadee04b0333
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01163.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01163")
+public class BenchmarkTest01163 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01163");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01164.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01164.java
new file mode 100644
index 0000000000000000000000000000000000000000..5dfc70528ad7c4eca07694dc5a95306b2b401ab4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01164.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01164")
+public class BenchmarkTest01164 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01164");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01165.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01165.java
new file mode 100644
index 0000000000000000000000000000000000000000..440378a3ebbdf19c2d14963c74bb2d8d8473627d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01165.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01165")
+public class BenchmarkTest01165 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01165");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a91034 = param; // assign
+            StringBuilder b91034 = new StringBuilder(a91034); // stick in stringbuilder
+            b91034.append(" SafeStuff"); // append some safe content
+            b91034.replace(
+                    b91034.length() - "Chars".length(),
+                    b91034.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map91034 = new java.util.HashMap<String, Object>();
+            map91034.put("key91034", b91034.toString()); // put in a collection
+            String c91034 = (String) map91034.get("key91034"); // get it back out
+            String d91034 = c91034.substring(0, c91034.length() - 1); // extract most of it
+            String e91034 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d91034.getBytes()))); // B64 encode and decode it
+            String f91034 = e91034.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g91034 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g91034); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01166.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01166.java
new file mode 100644
index 0000000000000000000000000000000000000000..af8f95adb8fef3f212c07d62f23523440db5c0e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01166.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01166")
+public class BenchmarkTest01166 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01166");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz52006 = new StringBuilder(param);
+                bar =
+                        sbxyz52006
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01167.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01167.java
new file mode 100644
index 0000000000000000000000000000000000000000..bddebcac1b97b5da4cbe8172296cd54edca3dc34
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01167.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01167")
+public class BenchmarkTest01167 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01167");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map70586 = new java.util.HashMap<String, Object>();
+            map70586.put("keyA-70586", "a-Value"); // put some stuff in the collection
+            map70586.put("keyB-70586", param); // put it in a collection
+            map70586.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map70586.get("keyB-70586"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01168.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01168.java
new file mode 100644
index 0000000000000000000000000000000000000000..9295312e4d623ed63e4a630bae652c179dd289a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01168.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01168")
+public class BenchmarkTest01168 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01168");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01169.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01169.java
new file mode 100644
index 0000000000000000000000000000000000000000..535abef7e73bcdcf9e8339368d0240f53581025d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01169.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01169")
+public class BenchmarkTest01169 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01169");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01170.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01170.java
new file mode 100644
index 0000000000000000000000000000000000000000..c163efad07125ba66b58b55d852a5122fd608024
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01170.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01170")
+public class BenchmarkTest01170 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01170");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01171.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01171.java
new file mode 100644
index 0000000000000000000000000000000000000000..740b20fafcd68bbeb62182d994e991f94194985c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01171.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01171")
+public class BenchmarkTest01171 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz83647 = new StringBuilder(param);
+                bar =
+                        sbxyz83647
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01172.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01172.java
new file mode 100644
index 0000000000000000000000000000000000000000..26200ab1c7389c9b39fbe5d881e522b0e1e56bd6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01172.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01172")
+public class BenchmarkTest01172 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map35084 = new java.util.HashMap<String, Object>();
+            map35084.put("keyA-35084", "a-Value"); // put some stuff in the collection
+            map35084.put("keyB-35084", param); // put it in a collection
+            map35084.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map35084.get("keyB-35084"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01173.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01173.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c55bc29980e95c8e22d394d5fc7c3add6d20976
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01173.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01173")
+public class BenchmarkTest01173 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01174.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01174.java
new file mode 100644
index 0000000000000000000000000000000000000000..b59372f9a043ef163fb9f6b9a424fdc81e2b2016
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01174.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01174")
+public class BenchmarkTest01174 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01175.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01175.java
new file mode 100644
index 0000000000000000000000000000000000000000..48a02cb643aad885c430c61d8ef5808542f5e6df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01175.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01175")
+public class BenchmarkTest01175 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01176.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01176.java
new file mode 100644
index 0000000000000000000000000000000000000000..92598b11409d9727289814b8dc626992834ef0bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01176.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01176")
+public class BenchmarkTest01176 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01177.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01177.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3faed5b0226c550c72fe1cfb5001aa73b6e7290
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01177.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01177")
+public class BenchmarkTest01177 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01178.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01178.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fd1e4e05ef9ed782948c1d6b244884d7b3bbf85
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01178.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01178")
+public class BenchmarkTest01178 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz69428 = new StringBuilder(param);
+            String bar = sbxyz69428.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01179.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01179.java
new file mode 100644
index 0000000000000000000000000000000000000000..09f683838959376c01f09da0ff12db8a0a897e8f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01179.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01179")
+public class BenchmarkTest01179 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01180.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01180.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd42f94814ee5f0a395d0014d172adc622e44217
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01180.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01180")
+public class BenchmarkTest01180 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01181.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01181.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c81514f0e59561e722e54d1d9247010aa0fe439
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01181.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01181")
+public class BenchmarkTest01181 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01182.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01182.java
new file mode 100644
index 0000000000000000000000000000000000000000..f25cb315515f6671a489a3ade6fb019043111c31
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01182.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01182")
+public class BenchmarkTest01182 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01182");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01183.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01183.java
new file mode 100644
index 0000000000000000000000000000000000000000..7518635fba089bf1dd511f64085162b7457259f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01183.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01183")
+public class BenchmarkTest01183 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01183");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01184.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01184.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b3fd59dbd501e82170e7a778bb68bd105b5b333
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01184.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01184")
+public class BenchmarkTest01184 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01184");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01185.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01185.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b8c59cdccf22b8f9011f4ae0cc8b5cb5a3c1305
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01185.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01185")
+public class BenchmarkTest01185 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01185");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01186.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01186.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e408524b793b9902aff91b6282a6a132e5254db
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01186.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01186")
+public class BenchmarkTest01186 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01186");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01187.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01187.java
new file mode 100644
index 0000000000000000000000000000000000000000..5ffd7a0d2baab31e4ae9334f2876ebcba07bd666
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01187.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01187")
+public class BenchmarkTest01187 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01187");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01188.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01188.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc8a06c666df7aed2d241fa7a37ce087831c9bf9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01188.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01188")
+public class BenchmarkTest01188 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01189.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01189.java
new file mode 100644
index 0000000000000000000000000000000000000000..4fe4655d6175c152b711771e0b2029195262cd52
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01189.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01189")
+public class BenchmarkTest01189 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01189");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01190.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01190.java
new file mode 100644
index 0000000000000000000000000000000000000000..16a2c0fccf58915a541d3835ca4b616e3446b730
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01190.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01190")
+public class BenchmarkTest01190 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01190");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01191.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01191.java
new file mode 100644
index 0000000000000000000000000000000000000000..3036bbbb1f2dfaaa228c663fb9a27d115482f48d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01191.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01191")
+public class BenchmarkTest01191 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01191");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01192.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01192.java
new file mode 100644
index 0000000000000000000000000000000000000000..31075caf110480445bd70d83d392300e97139d82
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01192.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01192")
+public class BenchmarkTest01192 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01192");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01193.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01193.java
new file mode 100644
index 0000000000000000000000000000000000000000..a32ce03b8bf6a29c7f5bb51537d9a96dc7188f64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01193.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01193")
+public class BenchmarkTest01193 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01193");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01194.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01194.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a0046c0718d32bf024198d026eb080bca44f04e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01194.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01194")
+public class BenchmarkTest01194 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01194");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01195.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01195.java
new file mode 100644
index 0000000000000000000000000000000000000000..4189febb305333baea888f98b820da4cbff78f49
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01195.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01195")
+public class BenchmarkTest01195 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01195");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01196.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01196.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c36c13218e871084b8ba3c542dacd88e0f019a2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01196.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01196")
+public class BenchmarkTest01196 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01196");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01197.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01197.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f336b2177fc37b853d800ce45079b0a03557c71
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01197.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01197")
+public class BenchmarkTest01197 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01197");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz6066 = new StringBuilder(param);
+            String bar = sbxyz6066.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01198.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01198.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a85f33e5fcab346d4dff849d7737145545c7be5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01198.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01198")
+public class BenchmarkTest01198 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01198");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01199.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01199.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b8cbd3b4c1869c464f068325434f25c3b042c4b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01199.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01199")
+public class BenchmarkTest01199 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01199");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01200.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01200.java
new file mode 100644
index 0000000000000000000000000000000000000000..598d04337199ec4a980dc637b3dc47b33f4db701
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01200.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01200")
+public class BenchmarkTest01200 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01200");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01201.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01201.java
new file mode 100644
index 0000000000000000000000000000000000000000..85ad868fdc819a346b68b93c9b4bfd50885378fe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01201.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01201")
+public class BenchmarkTest01201 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01201");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01202.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01202.java
new file mode 100644
index 0000000000000000000000000000000000000000..248429f238a70ea5b3ccc99e1737fe4fe28bac34
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01202.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01202")
+public class BenchmarkTest01202 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01202");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01203.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01203.java
new file mode 100644
index 0000000000000000000000000000000000000000..a13881559420cdfec730a6c5ee073cc610a1c219
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01203.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01203")
+public class BenchmarkTest01203 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01203");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map72700 = new java.util.HashMap<String, Object>();
+            map72700.put("keyA-72700", "a-Value"); // put some stuff in the collection
+            map72700.put("keyB-72700", param); // put it in a collection
+            map72700.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map72700.get("keyB-72700"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01204.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01204.java
new file mode 100644
index 0000000000000000000000000000000000000000..68751f6dae9c656fde1aece65afee3abe7b4623c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01204.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01204")
+public class BenchmarkTest01204 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01204");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a40584 = param; // assign
+            StringBuilder b40584 = new StringBuilder(a40584); // stick in stringbuilder
+            b40584.append(" SafeStuff"); // append some safe content
+            b40584.replace(
+                    b40584.length() - "Chars".length(),
+                    b40584.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map40584 = new java.util.HashMap<String, Object>();
+            map40584.put("key40584", b40584.toString()); // put in a collection
+            String c40584 = (String) map40584.get("key40584"); // get it back out
+            String d40584 = c40584.substring(0, c40584.length() - 1); // extract most of it
+            String e40584 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d40584.getBytes()))); // B64 encode and decode it
+            String f40584 = e40584.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f40584); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01205.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01205.java
new file mode 100644
index 0000000000000000000000000000000000000000..e466ab1ffbc99e097686a622c00ffd16e9545fbd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01205.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01205")
+public class BenchmarkTest01205 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01205");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01206.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01206.java
new file mode 100644
index 0000000000000000000000000000000000000000..48eff89141e2cbace829ead9d3346fd203ee33b9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01206.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01206")
+public class BenchmarkTest01206 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01206");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz14623 = new StringBuilder(param);
+                bar =
+                        sbxyz14623
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01207.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01207.java
new file mode 100644
index 0000000000000000000000000000000000000000..32b9a96727a3bb7e60939ba5864915dd25eab4cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01207.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01207")
+public class BenchmarkTest01207 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01207");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map95902 = new java.util.HashMap<String, Object>();
+            map95902.put("keyA-95902", "a_Value"); // put some stuff in the collection
+            map95902.put("keyB-95902", param); // put it in a collection
+            map95902.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map95902.get("keyB-95902"); // get it back out
+            bar = (String) map95902.get("keyA-95902"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01208.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01208.java
new file mode 100644
index 0000000000000000000000000000000000000000..71417c1ce50b17cbd820662acc5b813e0bb1a493
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01208.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01208")
+public class BenchmarkTest01208 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01208");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01209.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01209.java
new file mode 100644
index 0000000000000000000000000000000000000000..01163b2edd40f1e7702db3f8e68bc0fc8ea83500
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01209.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01209")
+public class BenchmarkTest01209 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01209");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01210.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01210.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd06a2cf67c4e51f493d8ac38d0d04e98f85bdcd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01210.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01210")
+public class BenchmarkTest01210 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01210");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map86576 = new java.util.HashMap<String, Object>();
+            map86576.put("keyA-86576", "a-Value"); // put some stuff in the collection
+            map86576.put("keyB-86576", param); // put it in a collection
+            map86576.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map86576.get("keyB-86576"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01211.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01211.java
new file mode 100644
index 0000000000000000000000000000000000000000..4552830ddfd9f7d197106a6ebfa0366311fe2853
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01211.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01211")
+public class BenchmarkTest01211 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01211");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01212.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01212.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa9aee8788666458321b2bba057389ce9fb82e23
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01212.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01212")
+public class BenchmarkTest01212 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01212");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01213.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01213.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1645dd65c80d6cdac72a06c664b2a5525a1bfc2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01213.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01213")
+public class BenchmarkTest01213 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01213");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01214.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01214.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac7a168f448b9552ab751aba39c8ad6681849908
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01214.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01214")
+public class BenchmarkTest01214 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01214");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01215.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01215.java
new file mode 100644
index 0000000000000000000000000000000000000000..45f564b5fda4061b1682569c7eab0d25db81ef71
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01215.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01215")
+public class BenchmarkTest01215 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01215");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01216.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01216.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f6972908b025854ed3435f19fa41cfabea01bd1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01216.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01216")
+public class BenchmarkTest01216 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01216");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01217.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01217.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c9c512e1579b299f109a29e65646b5cec42b802
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01217.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01217")
+public class BenchmarkTest01217 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01217");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a89502 = param; // assign
+            StringBuilder b89502 = new StringBuilder(a89502); // stick in stringbuilder
+            b89502.append(" SafeStuff"); // append some safe content
+            b89502.replace(
+                    b89502.length() - "Chars".length(),
+                    b89502.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map89502 = new java.util.HashMap<String, Object>();
+            map89502.put("key89502", b89502.toString()); // put in a collection
+            String c89502 = (String) map89502.get("key89502"); // get it back out
+            String d89502 = c89502.substring(0, c89502.length() - 1); // extract most of it
+            String e89502 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d89502.getBytes()))); // B64 encode and decode it
+            String f89502 = e89502.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g89502 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g89502); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01218.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01218.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb0a4f988202aab412b7197ff49230d0299d6878
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01218.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01218")
+public class BenchmarkTest01218 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01218");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01219.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01219.java
new file mode 100644
index 0000000000000000000000000000000000000000..38dc1b12751509b67fa171b7d2b21a1935f8604a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01219.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01219")
+public class BenchmarkTest01219 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01219");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map23263 = new java.util.HashMap<String, Object>();
+            map23263.put("keyA-23263", "a_Value"); // put some stuff in the collection
+            map23263.put("keyB-23263", param); // put it in a collection
+            map23263.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map23263.get("keyB-23263"); // get it back out
+            bar = (String) map23263.get("keyA-23263"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01220.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01220.java
new file mode 100644
index 0000000000000000000000000000000000000000..5da92201d8e65fb18e2cc7eba0aae362d98a6343
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01220.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01220")
+public class BenchmarkTest01220 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01220");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01221.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01221.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c5f6bed1bbecd0016775e58b6434415daaa5aba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01221.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01221")
+public class BenchmarkTest01221 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01221");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01222.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01222.java
new file mode 100644
index 0000000000000000000000000000000000000000..412584c2cc513fa8346307115ebce8c94f5df390
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01222.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01222")
+public class BenchmarkTest01222 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01222");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map25738 = new java.util.HashMap<String, Object>();
+            map25738.put("keyA-25738", "a-Value"); // put some stuff in the collection
+            map25738.put("keyB-25738", param); // put it in a collection
+            map25738.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map25738.get("keyB-25738"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01223.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01223.java
new file mode 100644
index 0000000000000000000000000000000000000000..e357e03839f558eb6f5eb20bacd6eb99ef8c99a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01223.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01223")
+public class BenchmarkTest01223 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01223");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01224.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01224.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c3f1838d71370526c31c7d4d55a24f1a002c812
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01224.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01224")
+public class BenchmarkTest01224 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01224");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01225.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01225.java
new file mode 100644
index 0000000000000000000000000000000000000000..68bf14f12ea1f581b94bcf58d6ad4a097c911982
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01225.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01225")
+public class BenchmarkTest01225 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest01225");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01226.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01226.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f6a8d89ae0158c690b0ebc1c6204ddf056062a6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01226.java	
@@ -0,0 +1,143 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01226")
+public class BenchmarkTest01226 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01226");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01227.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01227.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ed2e8a9a5c94d2341b539f1c726a3cb588c917d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01227.java	
@@ -0,0 +1,149 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01227")
+public class BenchmarkTest01227 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01227");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz39213 = new StringBuilder(param);
+                bar =
+                        sbxyz39213
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01228.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01228.java
new file mode 100644
index 0000000000000000000000000000000000000000..35b46a8af9735cc32658bca0e3c0070573f5a0f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01228.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01228")
+public class BenchmarkTest01228 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01228");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01229.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01229.java
new file mode 100644
index 0000000000000000000000000000000000000000..28d53260b8f6c25cf7dcd62a6ba09d92a956bbd8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01229.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01229")
+public class BenchmarkTest01229 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01229");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01230.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01230.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ede9dccfa659bc326fe2fa9fa457b1603e054cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01230.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01230")
+public class BenchmarkTest01230 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01230");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz45958 = new StringBuilder(param);
+            String bar = sbxyz45958.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01231.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01231.java
new file mode 100644
index 0000000000000000000000000000000000000000..348f29d2fa5f14c30c622ab83c15bc5ad07e64fc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01231.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01231")
+public class BenchmarkTest01231 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01231");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map35717 = new java.util.HashMap<String, Object>();
+            map35717.put("keyA-35717", "a-Value"); // put some stuff in the collection
+            map35717.put("keyB-35717", param); // put it in a collection
+            map35717.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map35717.get("keyB-35717"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01232.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01232.java
new file mode 100644
index 0000000000000000000000000000000000000000..10030226832d1ad8905f21dbee0c8cbca419cc12
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01232.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01232")
+public class BenchmarkTest01232 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01232");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01233.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01233.java
new file mode 100644
index 0000000000000000000000000000000000000000..68b10342435b28cbc6cea994a1a607727ea86af4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01233.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01233")
+public class BenchmarkTest01233 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01233");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01234.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01234.java
new file mode 100644
index 0000000000000000000000000000000000000000..63ac0b589a395e4abc9f4cb55071e598062fdec3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01234.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01234")
+public class BenchmarkTest01234 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01234");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01235.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01235.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2d1ae1aec8aad626498cdf31daaac03495a5ef8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01235.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01235")
+public class BenchmarkTest01235 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01235");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map13886 = new java.util.HashMap<String, Object>();
+            map13886.put("keyA-13886", "a-Value"); // put some stuff in the collection
+            map13886.put("keyB-13886", param); // put it in a collection
+            map13886.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map13886.get("keyB-13886"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01236.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01236.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab710fa05817f882c7646f39cef8ba1c3291f4ae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01236.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01236")
+public class BenchmarkTest01236 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01236");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01237.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01237.java
new file mode 100644
index 0000000000000000000000000000000000000000..148fabd02c0121a76baaf8f0d0b57251130e8e6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01237.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01237")
+public class BenchmarkTest01237 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01237");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01238.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01238.java
new file mode 100644
index 0000000000000000000000000000000000000000..4835551fd443f69fcff2be559b0d51752dd02605
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01238.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01238")
+public class BenchmarkTest01238 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01238");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01239.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01239.java
new file mode 100644
index 0000000000000000000000000000000000000000..b7b3888206ebac3218620da76f95ac64ee12254a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01239.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01239")
+public class BenchmarkTest01239 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01239");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01240.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01240.java
new file mode 100644
index 0000000000000000000000000000000000000000..09ea563cde19ba3d8cf8a92e1d220dd3fbd477fb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01240.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01240")
+public class BenchmarkTest01240 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01240");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01241.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01241.java
new file mode 100644
index 0000000000000000000000000000000000000000..178cf6e6923b78aabae599c0665994929d278665
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01241.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01241")
+public class BenchmarkTest01241 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01241");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01242.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01242.java
new file mode 100644
index 0000000000000000000000000000000000000000..3916704513f8f95ed17244ba73773048cdffa14f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01242.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01242")
+public class BenchmarkTest01242 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01242");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01243.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01243.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f4bd6ed9363e95d9656e1dbfde14ab7ea61c2da
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01243.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01243")
+public class BenchmarkTest01243 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01243");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01244.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01244.java
new file mode 100644
index 0000000000000000000000000000000000000000..17fc19f525c461e10879ae8bf325f8cff87fe040
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01244.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01244")
+public class BenchmarkTest01244 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01244");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01245.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01245.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e7e7d6198e7a4dfc67d18a3cfe0df8c4b6f56ca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01245.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01245")
+public class BenchmarkTest01245 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01245");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01246.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01246.java
new file mode 100644
index 0000000000000000000000000000000000000000..498ffc22859b0ecc639cf6dccba45eff63b3aa3f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01246.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01246")
+public class BenchmarkTest01246 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01246");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01247.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01247.java
new file mode 100644
index 0000000000000000000000000000000000000000..97646a2a02203a9267516821b654ef5b864930d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01247.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01247")
+public class BenchmarkTest01247 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01247");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01248.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01248.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b3362d65b1e4dd8ef60b6d29dc05da87f6473e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01248.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01248")
+public class BenchmarkTest01248 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01248");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01249.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01249.java
new file mode 100644
index 0000000000000000000000000000000000000000..386e1b8cc0a381bd2bd294be0307f4650376d442
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01249.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01249")
+public class BenchmarkTest01249 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01249");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01250.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01250.java
new file mode 100644
index 0000000000000000000000000000000000000000..25fb8d87db6eb4409916ea6402b587f256a2b2ca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01250.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01250")
+public class BenchmarkTest01250 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01250");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01251.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01251.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5821bac93558115bbfb6dbdc7eda6fca12a221a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01251.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01251")
+public class BenchmarkTest01251 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01251");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01252.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01252.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a725b94ce05645b6b16724d78cd982ee7523b8e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01252.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01252")
+public class BenchmarkTest01252 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01252");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01253.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01253.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a364805fa4c988f8dc69a506770e09c6ea9f880
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01253.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01253")
+public class BenchmarkTest01253 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01253");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map15481 = new java.util.HashMap<String, Object>();
+            map15481.put("keyA-15481", "a-Value"); // put some stuff in the collection
+            map15481.put("keyB-15481", param); // put it in a collection
+            map15481.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map15481.get("keyB-15481"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01254.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01254.java
new file mode 100644
index 0000000000000000000000000000000000000000..857966f7f8329f7632a5024c233f2c7af0e3ecf1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01254.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01254")
+public class BenchmarkTest01254 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01254");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a23874 = param; // assign
+            StringBuilder b23874 = new StringBuilder(a23874); // stick in stringbuilder
+            b23874.append(" SafeStuff"); // append some safe content
+            b23874.replace(
+                    b23874.length() - "Chars".length(),
+                    b23874.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map23874 = new java.util.HashMap<String, Object>();
+            map23874.put("key23874", b23874.toString()); // put in a collection
+            String c23874 = (String) map23874.get("key23874"); // get it back out
+            String d23874 = c23874.substring(0, c23874.length() - 1); // extract most of it
+            String e23874 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d23874.getBytes()))); // B64 encode and decode it
+            String f23874 = e23874.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f23874); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01255.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01255.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5740c54a23607e7ca759214eccabfad987fc66d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01255.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01255")
+public class BenchmarkTest01255 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01255");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01256.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01256.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc030071d784accfcc5fe51bc22a9a9f543af302
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01256.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01256")
+public class BenchmarkTest01256 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01256");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01257.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01257.java
new file mode 100644
index 0000000000000000000000000000000000000000..b66531d2a752fb2a89fd9d22111808f7d9a728d5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01257.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01257")
+public class BenchmarkTest01257 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01257");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01258.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01258.java
new file mode 100644
index 0000000000000000000000000000000000000000..d068e046b80b1d8953c130c600f5c7dc136a499c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01258.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01258")
+public class BenchmarkTest01258 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01258");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01259.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01259.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1a6b601db20ddbe539e2f51c4b444040501198b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01259.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01259")
+public class BenchmarkTest01259 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01259");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map26093 = new java.util.HashMap<String, Object>();
+            map26093.put("keyA-26093", "a-Value"); // put some stuff in the collection
+            map26093.put("keyB-26093", param); // put it in a collection
+            map26093.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map26093.get("keyB-26093"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01260.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01260.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7d51ed09d5063c19c207dcba725c8978f62b171
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01260.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01260")
+public class BenchmarkTest01260 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01260");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01261.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01261.java
new file mode 100644
index 0000000000000000000000000000000000000000..38c1631b67f67fe812a6b0cc0eb5ecb3c98336e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01261.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01261")
+public class BenchmarkTest01261 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01261");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a34194 = param; // assign
+            StringBuilder b34194 = new StringBuilder(a34194); // stick in stringbuilder
+            b34194.append(" SafeStuff"); // append some safe content
+            b34194.replace(
+                    b34194.length() - "Chars".length(),
+                    b34194.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map34194 = new java.util.HashMap<String, Object>();
+            map34194.put("key34194", b34194.toString()); // put in a collection
+            String c34194 = (String) map34194.get("key34194"); // get it back out
+            String d34194 = c34194.substring(0, c34194.length() - 1); // extract most of it
+            String e34194 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d34194.getBytes()))); // B64 encode and decode it
+            String f34194 = e34194.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f34194); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01262.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01262.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a1d7b7be778a0cdcf023ae5e123b637aa15e111
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01262.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01262")
+public class BenchmarkTest01262 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01262");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01263.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01263.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c69282dd0ecef5a1f0923e251c71003287eabed
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01263.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01263")
+public class BenchmarkTest01263 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01263");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01264.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01264.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e20e37da6ebf5a594daddede72539063f9ccc16
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01264.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01264")
+public class BenchmarkTest01264 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01264");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01265.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01265.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e7b7618317df92d2a18c1ba3455abf56f4c5863
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01265.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01265")
+public class BenchmarkTest01265 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01265");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01266.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01266.java
new file mode 100644
index 0000000000000000000000000000000000000000..e527f57092c672361f99413bddc4953a7cf7b7f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01266.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01266")
+public class BenchmarkTest01266 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01266");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01267.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01267.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc11c08ec141be485460263e7f425caccaab089f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01267.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01267")
+public class BenchmarkTest01267 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01267");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map53210 = new java.util.HashMap<String, Object>();
+            map53210.put("keyA-53210", "a-Value"); // put some stuff in the collection
+            map53210.put("keyB-53210", param); // put it in a collection
+            map53210.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map53210.get("keyB-53210"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01268.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01268.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b5bdb57c77ec6d4ef67f03e34d3741300958b09
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01268.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01268")
+public class BenchmarkTest01268 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01268");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a92384 = param; // assign
+            StringBuilder b92384 = new StringBuilder(a92384); // stick in stringbuilder
+            b92384.append(" SafeStuff"); // append some safe content
+            b92384.replace(
+                    b92384.length() - "Chars".length(),
+                    b92384.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map92384 = new java.util.HashMap<String, Object>();
+            map92384.put("key92384", b92384.toString()); // put in a collection
+            String c92384 = (String) map92384.get("key92384"); // get it back out
+            String d92384 = c92384.substring(0, c92384.length() - 1); // extract most of it
+            String e92384 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d92384.getBytes()))); // B64 encode and decode it
+            String f92384 = e92384.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f92384); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01269.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01269.java
new file mode 100644
index 0000000000000000000000000000000000000000..328ee560dd7785cd4e8b2b5f5d643fd7d021adaf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01269.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01269")
+public class BenchmarkTest01269 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01269");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01270.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01270.java
new file mode 100644
index 0000000000000000000000000000000000000000..083a7ca99ad217ac403e1235b66fef1e3e05b9c8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01270.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01270")
+public class BenchmarkTest01270 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01270");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01271.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01271.java
new file mode 100644
index 0000000000000000000000000000000000000000..1359ca30a0ecc7dd6d570dc10242d277121a865e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01271.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01271")
+public class BenchmarkTest01271 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01271");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a4086 = param; // assign
+            StringBuilder b4086 = new StringBuilder(a4086); // stick in stringbuilder
+            b4086.append(" SafeStuff"); // append some safe content
+            b4086.replace(
+                    b4086.length() - "Chars".length(),
+                    b4086.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map4086 = new java.util.HashMap<String, Object>();
+            map4086.put("key4086", b4086.toString()); // put in a collection
+            String c4086 = (String) map4086.get("key4086"); // get it back out
+            String d4086 = c4086.substring(0, c4086.length() - 1); // extract most of it
+            String e4086 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d4086.getBytes()))); // B64 encode and decode it
+            String f4086 = e4086.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g4086 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g4086); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01272.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01272.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9873e9643fa69700dd2333ed7a8ecaace619cd6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01272.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01272")
+public class BenchmarkTest01272 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01272");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01273.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01273.java
new file mode 100644
index 0000000000000000000000000000000000000000..4154200616eba42115581d00ee0c2274ff419ee2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01273.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01273")
+public class BenchmarkTest01273 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01273");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01274.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01274.java
new file mode 100644
index 0000000000000000000000000000000000000000..59e8051e1d65553ae3400e98a3b4c44918bda6c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01274.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01274")
+public class BenchmarkTest01274 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01274");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01275.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01275.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e2eeb2cf24d95fdecd68415694e90e46df471ed
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01275.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01275")
+public class BenchmarkTest01275 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01275");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz27989 = new StringBuilder(param);
+            String bar = sbxyz27989.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01276.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01276.java
new file mode 100644
index 0000000000000000000000000000000000000000..db71426400878f4562c098343f2753307011070b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01276.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01276")
+public class BenchmarkTest01276 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01276");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a83599 = param; // assign
+            StringBuilder b83599 = new StringBuilder(a83599); // stick in stringbuilder
+            b83599.append(" SafeStuff"); // append some safe content
+            b83599.replace(
+                    b83599.length() - "Chars".length(),
+                    b83599.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map83599 = new java.util.HashMap<String, Object>();
+            map83599.put("key83599", b83599.toString()); // put in a collection
+            String c83599 = (String) map83599.get("key83599"); // get it back out
+            String d83599 = c83599.substring(0, c83599.length() - 1); // extract most of it
+            String e83599 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d83599.getBytes()))); // B64 encode and decode it
+            String f83599 = e83599.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f83599); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01277.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01277.java
new file mode 100644
index 0000000000000000000000000000000000000000..5205be899c6269990656b80eb99e6fac266026ce
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01277.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01277")
+public class BenchmarkTest01277 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01277");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01278.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01278.java
new file mode 100644
index 0000000000000000000000000000000000000000..de26dac7a5c0b7a9de499b6f9e658d78a2f2048f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01278.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01278")
+public class BenchmarkTest01278 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01278");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01279.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01279.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd754ffb36bf5ad0d150e55d9b3a5342b583703e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01279.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01279")
+public class BenchmarkTest01279 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01279");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01280.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01280.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e76f39917b0c1cf69e5a48d89b9fad80740f7e5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01280.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01280")
+public class BenchmarkTest01280 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01280");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01281.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01281.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb328a8ab01eea4c52e105bce079c17e6362653c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01281.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01281")
+public class BenchmarkTest01281 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01281");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01282.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01282.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee0c85ab32f6135400d337fab99a8dd9f3c1497c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01282.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01282")
+public class BenchmarkTest01282 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01282");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01283.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01283.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f216a40a1b4b214097a25ac722de622888bb059
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01283.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01283")
+public class BenchmarkTest01283 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01283");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01284.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01284.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d2e7757e005f6e2e2591ac25e9d134c942e0b48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01284.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01284")
+public class BenchmarkTest01284 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01284");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01285.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01285.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2b664c62114e9c0db3389a55a4ad409c851c55f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01285.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01285")
+public class BenchmarkTest01285 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01285");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01286.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01286.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c72c31a9565a5870d76f1dfb46d534d40bbfc0e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01286.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01286")
+public class BenchmarkTest01286 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01286");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01287.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01287.java
new file mode 100644
index 0000000000000000000000000000000000000000..483778bdd3c5758decedd03c80c08d8b3295bd18
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01287.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01287")
+public class BenchmarkTest01287 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01287");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01288.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01288.java
new file mode 100644
index 0000000000000000000000000000000000000000..b48bba3b7373fe497fa6b6b4d60cf53d1ae8ef5c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01288.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01288")
+public class BenchmarkTest01288 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01288");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map58555 = new java.util.HashMap<String, Object>();
+            map58555.put("keyA-58555", "a-Value"); // put some stuff in the collection
+            map58555.put("keyB-58555", param); // put it in a collection
+            map58555.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map58555.get("keyB-58555"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01289.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01289.java
new file mode 100644
index 0000000000000000000000000000000000000000..936d9ded7dd496c230ca1d9e5a2f7c193d464eda
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01289.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01289")
+public class BenchmarkTest01289 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01289");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01290.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01290.java
new file mode 100644
index 0000000000000000000000000000000000000000..66bbe6d229af2414f6eeab8872bce5a2d521318a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01290.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01290")
+public class BenchmarkTest01290 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01290");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01291.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01291.java
new file mode 100644
index 0000000000000000000000000000000000000000..66b5f6b1913e2b170fa5d75e785ca4cca09e4bd2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01291.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01291")
+public class BenchmarkTest01291 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01291");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz42950 = new StringBuilder(param);
+                bar =
+                        sbxyz42950
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01292.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01292.java
new file mode 100644
index 0000000000000000000000000000000000000000..2eee9e4fb93888f61b65a34fc1e4669affb3b083
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01292.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01292")
+public class BenchmarkTest01292 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01292");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01293.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01293.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea07b5e3630df6af0ebd5ed87522bbae7db55927
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01293.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01293")
+public class BenchmarkTest01293 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01293");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01294.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01294.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c0fa3ef6085cc94d8c334eab07aeb025e62552a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01294.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01294")
+public class BenchmarkTest01294 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01294");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01295.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01295.java
new file mode 100644
index 0000000000000000000000000000000000000000..5444d996e234b9700ff43c3eab56ccd34e92cf68
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01295.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-02/BenchmarkTest01295")
+public class BenchmarkTest01295 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01295");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a22205 = param; // assign
+            StringBuilder b22205 = new StringBuilder(a22205); // stick in stringbuilder
+            b22205.append(" SafeStuff"); // append some safe content
+            b22205.replace(
+                    b22205.length() - "Chars".length(),
+                    b22205.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map22205 = new java.util.HashMap<String, Object>();
+            map22205.put("key22205", b22205.toString()); // put in a collection
+            String c22205 = (String) map22205.get("key22205"); // get it back out
+            String d22205 = c22205.substring(0, c22205.length() - 1); // extract most of it
+            String e22205 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d22205.getBytes()))); // B64 encode and decode it
+            String f22205 = e22205.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g22205 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g22205); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01296.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01296.java
new file mode 100644
index 0000000000000000000000000000000000000000..0aba42d0f72667a18f6604939e63961afb9d28e0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01296.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01296")
+public class BenchmarkTest01296 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01296");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01297.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01297.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb6a6b034be8712f08b5483e49fe11d03d3eaec9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01297.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01297")
+public class BenchmarkTest01297 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01297");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01298.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01298.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f089bcad3caa5e79111d686136ceb44b9ec27d5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01298.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01298")
+public class BenchmarkTest01298 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01298");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01299.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01299.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf4e1e4d768d3339e09835c0f2035a9282091697
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01299.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01299")
+public class BenchmarkTest01299 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01299");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01300.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01300.java
new file mode 100644
index 0000000000000000000000000000000000000000..4799e20d26e37ac424ff348f41d8459eeaef983a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01300.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01300")
+public class BenchmarkTest01300 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01300");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01301.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01301.java
new file mode 100644
index 0000000000000000000000000000000000000000..cbac41b87da53cb6d27709c40a8744e25d493dbc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01301.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01301")
+public class BenchmarkTest01301 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01301");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a11416 = param; // assign
+            StringBuilder b11416 = new StringBuilder(a11416); // stick in stringbuilder
+            b11416.append(" SafeStuff"); // append some safe content
+            b11416.replace(
+                    b11416.length() - "Chars".length(),
+                    b11416.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map11416 = new java.util.HashMap<String, Object>();
+            map11416.put("key11416", b11416.toString()); // put in a collection
+            String c11416 = (String) map11416.get("key11416"); // get it back out
+            String d11416 = c11416.substring(0, c11416.length() - 1); // extract most of it
+            String e11416 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d11416.getBytes()))); // B64 encode and decode it
+            String f11416 = e11416.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g11416 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g11416); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01302.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01302.java
new file mode 100644
index 0000000000000000000000000000000000000000..04a61e4d5bdfbe7af775af51001983f92de47db5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01302.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01302")
+public class BenchmarkTest01302 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01302");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01303.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01303.java
new file mode 100644
index 0000000000000000000000000000000000000000..364b76f4174ee7fdb0dce35ee1df261becad4d4d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01303.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01303")
+public class BenchmarkTest01303 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01303");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01304.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01304.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb2bac4ca77cb7cd9bf5eddaecb6352530f74cdc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01304.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01304")
+public class BenchmarkTest01304 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01304");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01305.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01305.java
new file mode 100644
index 0000000000000000000000000000000000000000..de8602c0f0bd41d7f567a608e9862f3ffa2cb298
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01305.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01305")
+public class BenchmarkTest01305 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01305");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01306.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01306.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8b24e2beaf386633d70a9bd7080cf06b69359bc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01306.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01306")
+public class BenchmarkTest01306 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01306");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01307.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01307.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7e15096eb8976a9d1b663b5e5d86cf603f5c27e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01307.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01307")
+public class BenchmarkTest01307 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01307");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01308.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01308.java
new file mode 100644
index 0000000000000000000000000000000000000000..beef825e94814432dc96b7126aa8612fa4eef439
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01308.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01308")
+public class BenchmarkTest01308 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01308");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01309.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01309.java
new file mode 100644
index 0000000000000000000000000000000000000000..105247a63104e355c707cdc57355f9f430b814cb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01309.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01309")
+public class BenchmarkTest01309 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01309");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a9334 = param; // assign
+            StringBuilder b9334 = new StringBuilder(a9334); // stick in stringbuilder
+            b9334.append(" SafeStuff"); // append some safe content
+            b9334.replace(
+                    b9334.length() - "Chars".length(),
+                    b9334.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map9334 = new java.util.HashMap<String, Object>();
+            map9334.put("key9334", b9334.toString()); // put in a collection
+            String c9334 = (String) map9334.get("key9334"); // get it back out
+            String d9334 = c9334.substring(0, c9334.length() - 1); // extract most of it
+            String e9334 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d9334.getBytes()))); // B64 encode and decode it
+            String f9334 = e9334.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g9334 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g9334); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01310.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01310.java
new file mode 100644
index 0000000000000000000000000000000000000000..f19badbf541ea4fc211be1810128ab41879ea4aa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01310.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01310")
+public class BenchmarkTest01310 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01310");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01311.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01311.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c3d97ff608d022c8a143393e518c0a352f7f5b7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01311.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01311")
+public class BenchmarkTest01311 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01311");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01312.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01312.java
new file mode 100644
index 0000000000000000000000000000000000000000..a9eaf0830c2cb9418eecbe7e72100693a09726bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01312.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01312")
+public class BenchmarkTest01312 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01312");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01313.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01313.java
new file mode 100644
index 0000000000000000000000000000000000000000..175c46e7479092d9b139379eb769673d9b21f752
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01313.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01313")
+public class BenchmarkTest01313 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01313");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01314.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01314.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1ab23832aaf546b8d2cb7051732d6762ad024fe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01314.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01314")
+public class BenchmarkTest01314 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01314");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01315.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01315.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4d0c48c57862d91e9e1d87aa12c60d580cf0690
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01315.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01315")
+public class BenchmarkTest01315 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01315");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01316.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01316.java
new file mode 100644
index 0000000000000000000000000000000000000000..430f3a462a9efe1efeea5bd8c0667083eeae91ff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01316.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01316")
+public class BenchmarkTest01316 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest01316");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01317.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01317.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac6c4dbac30e714e92bdcf35baf3b4fa1e11bc2e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01317.java	
@@ -0,0 +1,155 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01317")
+public class BenchmarkTest01317 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01317");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01318.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01318.java
new file mode 100644
index 0000000000000000000000000000000000000000..e41f2af7a14cf12a72505992545bbd0f1edef2e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01318.java	
@@ -0,0 +1,166 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01318")
+public class BenchmarkTest01318 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01318");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a66881 = param; // assign
+            StringBuilder b66881 = new StringBuilder(a66881); // stick in stringbuilder
+            b66881.append(" SafeStuff"); // append some safe content
+            b66881.replace(
+                    b66881.length() - "Chars".length(),
+                    b66881.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map66881 = new java.util.HashMap<String, Object>();
+            map66881.put("key66881", b66881.toString()); // put in a collection
+            String c66881 = (String) map66881.get("key66881"); // get it back out
+            String d66881 = c66881.substring(0, c66881.length() - 1); // extract most of it
+            String e66881 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d66881.getBytes()))); // B64 encode and decode it
+            String f66881 = e66881.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g66881 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g66881); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01319.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01319.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5ae6c2d166902406f2562df75e0e2efaa3b3714
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01319.java	
@@ -0,0 +1,148 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01319")
+public class BenchmarkTest01319 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01319");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01320.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01320.java
new file mode 100644
index 0000000000000000000000000000000000000000..25254c01fd9451ebe12f51e99aba3af895a1d438
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01320.java	
@@ -0,0 +1,156 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01320")
+public class BenchmarkTest01320 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01320");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01321.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01321.java
new file mode 100644
index 0000000000000000000000000000000000000000..735077077886b612b5d93b2314017380da23b52c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01321.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01321")
+public class BenchmarkTest01321 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01321");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01322.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01322.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a42a747e3f25a15c10b1bd5d2dca8a32652cc8e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01322.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01322")
+public class BenchmarkTest01322 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01322");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01323.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01323.java
new file mode 100644
index 0000000000000000000000000000000000000000..388451963426db2a5f0216b5ce73c703813c456a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01323.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01323")
+public class BenchmarkTest01323 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01323");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map1195 = new java.util.HashMap<String, Object>();
+            map1195.put("keyA-1195", "a-Value"); // put some stuff in the collection
+            map1195.put("keyB-1195", param); // put it in a collection
+            map1195.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map1195.get("keyB-1195"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01324.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01324.java
new file mode 100644
index 0000000000000000000000000000000000000000..da17dd2d8db1cc10d6ae77246313434be5e0092b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01324.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01324")
+public class BenchmarkTest01324 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01324");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01325.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01325.java
new file mode 100644
index 0000000000000000000000000000000000000000..5cb7853d3aa0c30c235763ab868f51a4fa673b80
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01325.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01325")
+public class BenchmarkTest01325 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01325");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map39183 = new java.util.HashMap<String, Object>();
+            map39183.put("keyA-39183", "a_Value"); // put some stuff in the collection
+            map39183.put("keyB-39183", param); // put it in a collection
+            map39183.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map39183.get("keyB-39183"); // get it back out
+            bar = (String) map39183.get("keyA-39183"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01326.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01326.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd7fd359b686c1ee093c0155095a8fd153b86dd0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01326.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01326")
+public class BenchmarkTest01326 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01326");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01327.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01327.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e7f05eab0bb58ed3c63b00d2cf35a7c0d3e1791
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01327.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01327")
+public class BenchmarkTest01327 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01327");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map41804 = new java.util.HashMap<String, Object>();
+            map41804.put("keyA-41804", "a_Value"); // put some stuff in the collection
+            map41804.put("keyB-41804", param); // put it in a collection
+            map41804.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map41804.get("keyB-41804"); // get it back out
+            bar = (String) map41804.get("keyA-41804"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01328.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01328.java
new file mode 100644
index 0000000000000000000000000000000000000000..3afb4f7497631b23433093ba749742387913dac6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01328.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01328")
+public class BenchmarkTest01328 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01328");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a17973 = param; // assign
+            StringBuilder b17973 = new StringBuilder(a17973); // stick in stringbuilder
+            b17973.append(" SafeStuff"); // append some safe content
+            b17973.replace(
+                    b17973.length() - "Chars".length(),
+                    b17973.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map17973 = new java.util.HashMap<String, Object>();
+            map17973.put("key17973", b17973.toString()); // put in a collection
+            String c17973 = (String) map17973.get("key17973"); // get it back out
+            String d17973 = c17973.substring(0, c17973.length() - 1); // extract most of it
+            String e17973 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d17973.getBytes()))); // B64 encode and decode it
+            String f17973 = e17973.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g17973 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g17973); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01329.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01329.java
new file mode 100644
index 0000000000000000000000000000000000000000..48bdac756216505af00498928312399c2a6af13d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01329.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01329")
+public class BenchmarkTest01329 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01329");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01330.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01330.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc52859ac35ed46bc48725cd8ac25cc8ca87795d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01330.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01330")
+public class BenchmarkTest01330 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01330");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01331.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01331.java
new file mode 100644
index 0000000000000000000000000000000000000000..d79bc8c3688f6874a4486de11c6d128b300dd6ea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01331.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01331")
+public class BenchmarkTest01331 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01331");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01332.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01332.java
new file mode 100644
index 0000000000000000000000000000000000000000..18fe50f4de0deb1238530bb47c331bc34435cdc4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01332.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01332")
+public class BenchmarkTest01332 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01332");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz43527 = new StringBuilder(param);
+            String bar = sbxyz43527.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01333.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01333.java
new file mode 100644
index 0000000000000000000000000000000000000000..44dc7b20c4b06bd5f90d12d78207a0f64d18afed
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01333.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01333")
+public class BenchmarkTest01333 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01333");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01334.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01334.java
new file mode 100644
index 0000000000000000000000000000000000000000..25281aeedbaac25e9bbea41e773fad17ab3aab76
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01334.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01334")
+public class BenchmarkTest01334 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01334");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01335.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01335.java
new file mode 100644
index 0000000000000000000000000000000000000000..b10f3fbba93ee66d21fea40491a9bd5695fb8ba1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01335.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01335")
+public class BenchmarkTest01335 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01335");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map45376 = new java.util.HashMap<String, Object>();
+            map45376.put("keyA-45376", "a-Value"); // put some stuff in the collection
+            map45376.put("keyB-45376", param); // put it in a collection
+            map45376.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map45376.get("keyB-45376"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01336.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01336.java
new file mode 100644
index 0000000000000000000000000000000000000000..d98cf3546b938c0b56c7a07f2eaa6241a97761db
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01336.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01336")
+public class BenchmarkTest01336 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01336");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01337.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01337.java
new file mode 100644
index 0000000000000000000000000000000000000000..618bca9fa83dc95cfe79eb8cd3653db326a91cf2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01337.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01337")
+public class BenchmarkTest01337 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01337");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz24804 = new StringBuilder(param);
+            String bar = sbxyz24804.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01338.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01338.java
new file mode 100644
index 0000000000000000000000000000000000000000..597fa5b4ee5492c1be44b1c143a1ac98620a4553
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01338.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01338")
+public class BenchmarkTest01338 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01338");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01339.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01339.java
new file mode 100644
index 0000000000000000000000000000000000000000..db53664313f6599df6cc08cf650f9f622867c39f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01339.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01339")
+public class BenchmarkTest01339 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01339");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01340.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01340.java
new file mode 100644
index 0000000000000000000000000000000000000000..99d8bd43fbbea6da07e2c009b45b3e418d43ef1e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01340.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01340")
+public class BenchmarkTest01340 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01340");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map36950 = new java.util.HashMap<String, Object>();
+            map36950.put("keyA-36950", "a_Value"); // put some stuff in the collection
+            map36950.put("keyB-36950", param); // put it in a collection
+            map36950.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map36950.get("keyB-36950"); // get it back out
+            bar = (String) map36950.get("keyA-36950"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01341.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01341.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef01cbe49827cba8e7460ef1b853d7c4a471605f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01341.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01341")
+public class BenchmarkTest01341 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01341");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a41908 = param; // assign
+            StringBuilder b41908 = new StringBuilder(a41908); // stick in stringbuilder
+            b41908.append(" SafeStuff"); // append some safe content
+            b41908.replace(
+                    b41908.length() - "Chars".length(),
+                    b41908.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map41908 = new java.util.HashMap<String, Object>();
+            map41908.put("key41908", b41908.toString()); // put in a collection
+            String c41908 = (String) map41908.get("key41908"); // get it back out
+            String d41908 = c41908.substring(0, c41908.length() - 1); // extract most of it
+            String e41908 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d41908.getBytes()))); // B64 encode and decode it
+            String f41908 = e41908.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g41908 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g41908); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01342.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01342.java
new file mode 100644
index 0000000000000000000000000000000000000000..358973e179304e46761a23a4b64637280535b3f0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01342.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01342")
+public class BenchmarkTest01342 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01342");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01343.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01343.java
new file mode 100644
index 0000000000000000000000000000000000000000..ddc34c927e707d1d310baf877028b64e44367088
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01343.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01343")
+public class BenchmarkTest01343 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01343");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01344.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01344.java
new file mode 100644
index 0000000000000000000000000000000000000000..d659125d636c818644c911d2b17ff4596e9f73d2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01344.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01344")
+public class BenchmarkTest01344 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01344");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01345.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01345.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6d5154d651960968e7058ede67d05e81c533667
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01345.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01345")
+public class BenchmarkTest01345 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01345");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01346.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01346.java
new file mode 100644
index 0000000000000000000000000000000000000000..2827f75f7f099009d19f73bc781488c89ee137e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01346.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01346")
+public class BenchmarkTest01346 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01346");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01347.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01347.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e7d231ef6c16589b5790629410f7cd13171cfc3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01347.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01347")
+public class BenchmarkTest01347 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01347");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a81561 = param; // assign
+            StringBuilder b81561 = new StringBuilder(a81561); // stick in stringbuilder
+            b81561.append(" SafeStuff"); // append some safe content
+            b81561.replace(
+                    b81561.length() - "Chars".length(),
+                    b81561.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map81561 = new java.util.HashMap<String, Object>();
+            map81561.put("key81561", b81561.toString()); // put in a collection
+            String c81561 = (String) map81561.get("key81561"); // get it back out
+            String d81561 = c81561.substring(0, c81561.length() - 1); // extract most of it
+            String e81561 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d81561.getBytes()))); // B64 encode and decode it
+            String f81561 = e81561.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f81561); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01348.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01348.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c72e80be9b2e0cf0b9736c35b45d09c949c60a8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01348.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01348")
+public class BenchmarkTest01348 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01348");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01349.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01349.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5e46ed5478e8d7a8d4c4076f48e05dd205a9af6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01349.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01349")
+public class BenchmarkTest01349 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01349");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz63030 = new StringBuilder(param);
+            String bar = sbxyz63030.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01350.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01350.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7df83fa6b860d11c3062ead51debaccef485b1c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01350.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01350")
+public class BenchmarkTest01350 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01350");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01351.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01351.java
new file mode 100644
index 0000000000000000000000000000000000000000..49b2f49effbcb099f7f20fcd90075ed1dd2d016f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01351.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01351")
+public class BenchmarkTest01351 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01351");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01352.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01352.java
new file mode 100644
index 0000000000000000000000000000000000000000..95ef9ff80cc6bfdbdaab790e51e8456833eee533
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01352.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01352")
+public class BenchmarkTest01352 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01352");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01353.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01353.java
new file mode 100644
index 0000000000000000000000000000000000000000..00bd4768e754c8f84e3ac8b107dfc0c539f74228
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01353.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01353")
+public class BenchmarkTest01353 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01353");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01354.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01354.java
new file mode 100644
index 0000000000000000000000000000000000000000..7459e3432b64324611b7a50aacf74fa6c25aedcd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01354.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01354")
+public class BenchmarkTest01354 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01354");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01355.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01355.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1d8845cf7191d66fc7f83c7ac03141aefb456c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01355.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01355")
+public class BenchmarkTest01355 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01355");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01356.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01356.java
new file mode 100644
index 0000000000000000000000000000000000000000..44ce0eeb5958e7bfc4a45ebd60a33c58ebdde058
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01356.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01356")
+public class BenchmarkTest01356 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01356");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01357.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01357.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4f1b7505fe8480dca52ce070f8ba5e096034fb5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01357.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01357")
+public class BenchmarkTest01357 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01357");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01358.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01358.java
new file mode 100644
index 0000000000000000000000000000000000000000..36441a826ad760cdba508aada49bfd8763773793
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01358.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01358")
+public class BenchmarkTest01358 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01358");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01359.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01359.java
new file mode 100644
index 0000000000000000000000000000000000000000..33737d89bf2b13f68cd10f71bff5c98428bae2e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01359.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01359")
+public class BenchmarkTest01359 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01359");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01360.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01360.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a8b833c17f7521a84a103fef6765d99c44353af
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01360.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01360")
+public class BenchmarkTest01360 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01360");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01361.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01361.java
new file mode 100644
index 0000000000000000000000000000000000000000..da74e3da05506bc4b70654ea91bba1a3d8761760
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01361.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01361")
+public class BenchmarkTest01361 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01361");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01362.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01362.java
new file mode 100644
index 0000000000000000000000000000000000000000..40ecff1341e3c86ef2af5d236b395d2d213c6b01
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01362.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01362")
+public class BenchmarkTest01362 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01362");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01363.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01363.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab70e3a5572ea4de5654e61925d7541e23a11803
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01363.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01363")
+public class BenchmarkTest01363 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01363");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01364.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01364.java
new file mode 100644
index 0000000000000000000000000000000000000000..220228c306563da6064c8d12b5cbd3e6a8057836
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01364.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01364")
+public class BenchmarkTest01364 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01364");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01365.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01365.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a9e7730cf55a05e3cf94d512b2096060d7b7651
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01365.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01365")
+public class BenchmarkTest01365 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01365");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01366.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01366.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2df9b697d7b8a97dbd808e0af89114a4862e436
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01366.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01366")
+public class BenchmarkTest01366 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01366");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01367.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01367.java
new file mode 100644
index 0000000000000000000000000000000000000000..b46bd850a6898118b7f35d914b00f2fb4fa1ba63
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01367.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01367")
+public class BenchmarkTest01367 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01367");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01368.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01368.java
new file mode 100644
index 0000000000000000000000000000000000000000..4312d858f7db054aadbb74028043d9707cc94f20
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01368.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01368")
+public class BenchmarkTest01368 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01368");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01369.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01369.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2084f4c21b47cd74cda982694c86f8a657fc127
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01369.java	
@@ -0,0 +1,131 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01369")
+public class BenchmarkTest01369 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01369");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a43860 = param; // assign
+            StringBuilder b43860 = new StringBuilder(a43860); // stick in stringbuilder
+            b43860.append(" SafeStuff"); // append some safe content
+            b43860.replace(
+                    b43860.length() - "Chars".length(),
+                    b43860.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map43860 = new java.util.HashMap<String, Object>();
+            map43860.put("key43860", b43860.toString()); // put in a collection
+            String c43860 = (String) map43860.get("key43860"); // get it back out
+            String d43860 = c43860.substring(0, c43860.length() - 1); // extract most of it
+            String e43860 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d43860.getBytes()))); // B64 encode and decode it
+            String f43860 = e43860.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f43860); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01370.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01370.java
new file mode 100644
index 0000000000000000000000000000000000000000..f4b97385e7475d58f113ae5c445b2ddec9816b8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01370.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01370")
+public class BenchmarkTest01370 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01370");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01371.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01371.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e86cc0d701b011691a5858844e4a2fc744571b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01371.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01371")
+public class BenchmarkTest01371 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01371");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01372.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01372.java
new file mode 100644
index 0000000000000000000000000000000000000000..acf4bc8295c364112fd9f86c43110e962ee0d0dc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01372.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01372")
+public class BenchmarkTest01372 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01372");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01373.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01373.java
new file mode 100644
index 0000000000000000000000000000000000000000..0dcec08b9091508ac31993152f5912db02e32e3b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01373.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01373")
+public class BenchmarkTest01373 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01373");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01374.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01374.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f5234d7c905cfa7e9b4508895d1cf599dbf966b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01374.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01374")
+public class BenchmarkTest01374 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01374");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01375.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01375.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b38686d21ac26dfd8bdae82b8c5cd25a70a420a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01375.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01375")
+public class BenchmarkTest01375 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01375");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a33070 = param; // assign
+            StringBuilder b33070 = new StringBuilder(a33070); // stick in stringbuilder
+            b33070.append(" SafeStuff"); // append some safe content
+            b33070.replace(
+                    b33070.length() - "Chars".length(),
+                    b33070.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map33070 = new java.util.HashMap<String, Object>();
+            map33070.put("key33070", b33070.toString()); // put in a collection
+            String c33070 = (String) map33070.get("key33070"); // get it back out
+            String d33070 = c33070.substring(0, c33070.length() - 1); // extract most of it
+            String e33070 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d33070.getBytes()))); // B64 encode and decode it
+            String f33070 = e33070.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f33070); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01376.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01376.java
new file mode 100644
index 0000000000000000000000000000000000000000..f76d5dd3463487e9f3719b81215782204fc82738
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01376.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01376")
+public class BenchmarkTest01376 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01376");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01377.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01377.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ec626cfd2f267f965898aced4c479f7fcab481f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01377.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01377")
+public class BenchmarkTest01377 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01377");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01378.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01378.java
new file mode 100644
index 0000000000000000000000000000000000000000..211f73f953be4bb5bd572f3da887475b0bbc9d35
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01378.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01378")
+public class BenchmarkTest01378 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01378");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a50098 = param; // assign
+            StringBuilder b50098 = new StringBuilder(a50098); // stick in stringbuilder
+            b50098.append(" SafeStuff"); // append some safe content
+            b50098.replace(
+                    b50098.length() - "Chars".length(),
+                    b50098.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map50098 = new java.util.HashMap<String, Object>();
+            map50098.put("key50098", b50098.toString()); // put in a collection
+            String c50098 = (String) map50098.get("key50098"); // get it back out
+            String d50098 = c50098.substring(0, c50098.length() - 1); // extract most of it
+            String e50098 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d50098.getBytes()))); // B64 encode and decode it
+            String f50098 = e50098.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g50098 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g50098); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01379.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01379.java
new file mode 100644
index 0000000000000000000000000000000000000000..6448444c9c70e58df313b26a4eb586c983482ad4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01379.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01379")
+public class BenchmarkTest01379 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01379");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01380.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01380.java
new file mode 100644
index 0000000000000000000000000000000000000000..e75c58c3a120722417bba6ae9b2c2efd5a6537af
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01380.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01380")
+public class BenchmarkTest01380 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01380");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01381.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01381.java
new file mode 100644
index 0000000000000000000000000000000000000000..b547f05f85d40558ece9685ef30e22e6b3586514
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01381.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01381")
+public class BenchmarkTest01381 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01381");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01382.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01382.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac3453ef17cd3110b5d2773945097a569e6c3ac0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01382.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01382")
+public class BenchmarkTest01382 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01382");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01383.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01383.java
new file mode 100644
index 0000000000000000000000000000000000000000..4732410a709f34fc6a2a5f5f48094a9481d61e39
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01383.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01383")
+public class BenchmarkTest01383 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01383");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01384.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01384.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea4246ec7140b3a71ae308d56233c3b1c9917e69
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01384.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01384")
+public class BenchmarkTest01384 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01384");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01385.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01385.java
new file mode 100644
index 0000000000000000000000000000000000000000..235471e7cd9f97e07a6274528279b38509da67d3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01385.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01385")
+public class BenchmarkTest01385 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01385");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01386.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01386.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c242ef8d0265fdd5a2e6378718e40622cb7283e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01386.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01386")
+public class BenchmarkTest01386 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01386");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01387.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01387.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe3ecf01259d8a948c085396bbec4466d377cdef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01387.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01387")
+public class BenchmarkTest01387 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01387");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01388.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01388.java
new file mode 100644
index 0000000000000000000000000000000000000000..809cc9421f8af935840658c1038e5ebc29367e9f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01388.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01388")
+public class BenchmarkTest01388 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01388");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01389.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01389.java
new file mode 100644
index 0000000000000000000000000000000000000000..f30967ed8a15ed72f7f723cd751bd063b191d178
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01389.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-02/BenchmarkTest01389")
+public class BenchmarkTest01389 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01389");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01390.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01390.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1b9bc30a77bb087f01da0413e000a69c3f41520
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01390.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01390")
+public class BenchmarkTest01390 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01390");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01391.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01391.java
new file mode 100644
index 0000000000000000000000000000000000000000..adff50065dbdf195c8d2312d61e527e4c9ecd7f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01391.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01391")
+public class BenchmarkTest01391 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01391");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map24596 = new java.util.HashMap<String, Object>();
+            map24596.put("keyA-24596", "a-Value"); // put some stuff in the collection
+            map24596.put("keyB-24596", param); // put it in a collection
+            map24596.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map24596.get("keyB-24596"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01392.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01392.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e602ebbcaf12b0e374e00150cd17a34a7e284e3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01392.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01392")
+public class BenchmarkTest01392 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01392");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01393.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01393.java
new file mode 100644
index 0000000000000000000000000000000000000000..14c02d67c12b567d71dd58398cea970dba3c933a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01393.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01393")
+public class BenchmarkTest01393 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01393");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a57571 = param; // assign
+            StringBuilder b57571 = new StringBuilder(a57571); // stick in stringbuilder
+            b57571.append(" SafeStuff"); // append some safe content
+            b57571.replace(
+                    b57571.length() - "Chars".length(),
+                    b57571.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map57571 = new java.util.HashMap<String, Object>();
+            map57571.put("key57571", b57571.toString()); // put in a collection
+            String c57571 = (String) map57571.get("key57571"); // get it back out
+            String d57571 = c57571.substring(0, c57571.length() - 1); // extract most of it
+            String e57571 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d57571.getBytes()))); // B64 encode and decode it
+            String f57571 = e57571.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g57571 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g57571); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01394.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01394.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7864d8ce63459e0e16c1e3f98ad8a14af826f6d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01394.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01394")
+public class BenchmarkTest01394 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01394");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01395.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01395.java
new file mode 100644
index 0000000000000000000000000000000000000000..626cc0c2ddcca36b85c3c6d831edf3a817b3f9b2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01395.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01395")
+public class BenchmarkTest01395 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01395");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01396.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01396.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd35c52894e1cfc6f5fa0f79511a5a8d490d6173
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01396.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01396")
+public class BenchmarkTest01396 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01396");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01397.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01397.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab047be8966227e1f390c527a934caff02997c8f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01397.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01397")
+public class BenchmarkTest01397 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest01397");
+            if (values != null) param = values[0];
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01398.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01398.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef9f10efd26be30cecac9b7ab6c7b629537ae395
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01398.java	
@@ -0,0 +1,180 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01398")
+public class BenchmarkTest01398 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01398")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a37227 = param; // assign
+            StringBuilder b37227 = new StringBuilder(a37227); // stick in stringbuilder
+            b37227.append(" SafeStuff"); // append some safe content
+            b37227.replace(
+                    b37227.length() - "Chars".length(),
+                    b37227.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map37227 = new java.util.HashMap<String, Object>();
+            map37227.put("key37227", b37227.toString()); // put in a collection
+            String c37227 = (String) map37227.get("key37227"); // get it back out
+            String d37227 = c37227.substring(0, c37227.length() - 1); // extract most of it
+            String e37227 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d37227.getBytes()))); // B64 encode and decode it
+            String f37227 = e37227.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g37227 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g37227); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01399.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01399.java
new file mode 100644
index 0000000000000000000000000000000000000000..261410f3d0b28f89a3133bda693f8e5a3fb5be9a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01399.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01399")
+public class BenchmarkTest01399 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01399")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01400.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01400.java
new file mode 100644
index 0000000000000000000000000000000000000000..89592e0ded394cdbf5bc991cd625660e3d92d305
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01400.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01400")
+public class BenchmarkTest01400 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01400")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01401.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01401.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8e6af28a534a83222d9c83fcb68234b43ad2e78
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01401.java	
@@ -0,0 +1,131 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01401")
+public class BenchmarkTest01401 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01401")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01402.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01402.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c56e9e2ddf78c4af8bffec9cf2d9ff7d8a9efd9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01402.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01402")
+public class BenchmarkTest01402 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01402")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01403.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01403.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a1b443843fe1402f2efa1281efea8b9f038a269
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01403.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01403")
+public class BenchmarkTest01403 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01403")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01404.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01404.java
new file mode 100644
index 0000000000000000000000000000000000000000..6030132a6168002c844f050de545ceabdd271364
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01404.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01404")
+public class BenchmarkTest01404 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01404")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a75056 = param; // assign
+            StringBuilder b75056 = new StringBuilder(a75056); // stick in stringbuilder
+            b75056.append(" SafeStuff"); // append some safe content
+            b75056.replace(
+                    b75056.length() - "Chars".length(),
+                    b75056.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map75056 = new java.util.HashMap<String, Object>();
+            map75056.put("key75056", b75056.toString()); // put in a collection
+            String c75056 = (String) map75056.get("key75056"); // get it back out
+            String d75056 = c75056.substring(0, c75056.length() - 1); // extract most of it
+            String e75056 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d75056.getBytes()))); // B64 encode and decode it
+            String f75056 = e75056.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g75056 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g75056); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01405.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01405.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f3a74dfbce308029e92c4dd1f61a0c72bf8f0c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01405.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01405")
+public class BenchmarkTest01405 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01405")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01406.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01406.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fb5dd4ceeec37b7f33c6774712bd98d289d71c8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01406.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01406")
+public class BenchmarkTest01406 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01406")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01407.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01407.java
new file mode 100644
index 0000000000000000000000000000000000000000..27f3fd02991ac44b51bd0b30dfff776520afd889
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01407.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01407")
+public class BenchmarkTest01407 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01407")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01408.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01408.java
new file mode 100644
index 0000000000000000000000000000000000000000..48ea4dd62504ca91ce7fc8fa6787d66eff220a64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01408.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01408")
+public class BenchmarkTest01408 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01408")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01409.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01409.java
new file mode 100644
index 0000000000000000000000000000000000000000..0869601aafeba630b9e91104d4564b590e75625a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01409.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01409")
+public class BenchmarkTest01409 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01409")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map58007 = new java.util.HashMap<String, Object>();
+            map58007.put("keyA-58007", "a_Value"); // put some stuff in the collection
+            map58007.put("keyB-58007", param); // put it in a collection
+            map58007.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map58007.get("keyB-58007"); // get it back out
+            bar = (String) map58007.get("keyA-58007"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01410.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01410.java
new file mode 100644
index 0000000000000000000000000000000000000000..514f19201370a3386c3ad6533773d688e5fc7ef0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01410.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01410")
+public class BenchmarkTest01410 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01410")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01411.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01411.java
new file mode 100644
index 0000000000000000000000000000000000000000..b62916175daae0e9be197734b7ec7789072cf0b4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01411.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01411")
+public class BenchmarkTest01411 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01411")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01412.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01412.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1e4286ce7092df2a4fceceb1fa25ebc0b00c7d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01412.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01412")
+public class BenchmarkTest01412 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01412")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01413.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01413.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4679015388bde6e3d7b78d6045c3f0d3f952701
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01413.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01413")
+public class BenchmarkTest01413 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01413")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01414.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01414.java
new file mode 100644
index 0000000000000000000000000000000000000000..30e2b8c9af6ec12420de996b3f6bb374bb40b168
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01414.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01414")
+public class BenchmarkTest01414 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01414")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01415.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01415.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd2ab1770cd77691efaba2a657822e6cc91508fb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01415.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01415")
+public class BenchmarkTest01415 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01415")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01416.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01416.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc532ef29751c6776ebcf5a792773622e002fa46
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01416.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01416")
+public class BenchmarkTest01416 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01416")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01417.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01417.java
new file mode 100644
index 0000000000000000000000000000000000000000..a05c8d8419c6645e34bd8896aa1b7a63ae2784a2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01417.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01417")
+public class BenchmarkTest01417 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01417")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01418.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01418.java
new file mode 100644
index 0000000000000000000000000000000000000000..0220608f7e53eba126c0c7f056578e77e80448cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01418.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01418")
+public class BenchmarkTest01418 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01418")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01419.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01419.java
new file mode 100644
index 0000000000000000000000000000000000000000..d5e9f356a3cead2ca6094c5930332807541b082a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01419.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01419")
+public class BenchmarkTest01419 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01419")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01420.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01420.java
new file mode 100644
index 0000000000000000000000000000000000000000..1774ec387e16dbc8e25e112e7a8621b0a83becaa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01420.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01420")
+public class BenchmarkTest01420 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01420")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01421.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01421.java
new file mode 100644
index 0000000000000000000000000000000000000000..a40cbd932f1649e868c5b3172981a18dd74fbd69
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01421.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01421")
+public class BenchmarkTest01421 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01421")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01422.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01422.java
new file mode 100644
index 0000000000000000000000000000000000000000..17b5d0d9ae8419b951cc83e23a2844814f2742e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01422.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01422")
+public class BenchmarkTest01422 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01422")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map80775 = new java.util.HashMap<String, Object>();
+            map80775.put("keyA-80775", "a_Value"); // put some stuff in the collection
+            map80775.put("keyB-80775", param); // put it in a collection
+            map80775.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map80775.get("keyB-80775"); // get it back out
+            bar = (String) map80775.get("keyA-80775"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01423.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01423.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ff9b80de0b9d0698c1275b004b3a4ea0300ab9c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01423.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01423")
+public class BenchmarkTest01423 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01423")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01424.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01424.java
new file mode 100644
index 0000000000000000000000000000000000000000..48ba581ee20d3ae80527bf8197920be94b2813e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01424.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01424")
+public class BenchmarkTest01424 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01424")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz93549 = new StringBuilder(param);
+            String bar = sbxyz93549.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01425.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01425.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6482e469d090d2f5088410885c539569bcdd253
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01425.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01425")
+public class BenchmarkTest01425 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01425")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01426.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01426.java
new file mode 100644
index 0000000000000000000000000000000000000000..105e0e8e0d34e496836cac4616ea5dcac99ad58f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01426.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01426")
+public class BenchmarkTest01426 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01426")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01427.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01427.java
new file mode 100644
index 0000000000000000000000000000000000000000..eac29e8b8fdfd9513f5ddf71986b64e7aa4b5b96
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01427.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01427")
+public class BenchmarkTest01427 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01427")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01428.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01428.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e075a2ad470f4a74a393bc638ca966ec9eb2d2d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01428.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01428")
+public class BenchmarkTest01428 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01428")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01429.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01429.java
new file mode 100644
index 0000000000000000000000000000000000000000..798692d08c0e6ba1e0441c4cf83435917a85325f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01429.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01429")
+public class BenchmarkTest01429 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01429")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01430.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01430.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb5a6492fd6b8583d5dc359efcf5decc6ab67d12
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01430.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01430")
+public class BenchmarkTest01430 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01430")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01431.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01431.java
new file mode 100644
index 0000000000000000000000000000000000000000..d13a92fadac6ebed4870aaff1ece673c00451905
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01431.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01431")
+public class BenchmarkTest01431 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01431")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01432.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01432.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a44bfa352b91ca26e08e00189e4c06405ed60bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01432.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01432")
+public class BenchmarkTest01432 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01432")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz18866 = new StringBuilder(param);
+                bar =
+                        sbxyz18866
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01433.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01433.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe563073ab069bd3c499451f449b31a790d1c3c1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01433.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01433")
+public class BenchmarkTest01433 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01433")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01434.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01434.java
new file mode 100644
index 0000000000000000000000000000000000000000..bbe5ed2e92ac89b527db24a5f8cd9f401ebb1606
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01434.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01434")
+public class BenchmarkTest01434 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01434")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01435.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01435.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e225e50b96ef0a8a1a55674cd6606d0a9c912e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01435.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01435")
+public class BenchmarkTest01435 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01435")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01436.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01436.java
new file mode 100644
index 0000000000000000000000000000000000000000..a6c7fb23089359da0ba4e3167742339048678dd1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01436.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01436")
+public class BenchmarkTest01436 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01436")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01437.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01437.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab1893d7eef03b1c980de90925d938d0016fe92c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01437.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01437")
+public class BenchmarkTest01437 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01437")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01438.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01438.java
new file mode 100644
index 0000000000000000000000000000000000000000..13aa45f0687d36fa4442194b8e5807c857b815b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01438.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01438")
+public class BenchmarkTest01438 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01438")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a32762 = param; // assign
+            StringBuilder b32762 = new StringBuilder(a32762); // stick in stringbuilder
+            b32762.append(" SafeStuff"); // append some safe content
+            b32762.replace(
+                    b32762.length() - "Chars".length(),
+                    b32762.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map32762 = new java.util.HashMap<String, Object>();
+            map32762.put("key32762", b32762.toString()); // put in a collection
+            String c32762 = (String) map32762.get("key32762"); // get it back out
+            String d32762 = c32762.substring(0, c32762.length() - 1); // extract most of it
+            String e32762 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d32762.getBytes()))); // B64 encode and decode it
+            String f32762 = e32762.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f32762); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01439.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01439.java
new file mode 100644
index 0000000000000000000000000000000000000000..d22a410ecd9cf561f9a8066565cad695b3fee712
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01439.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01439")
+public class BenchmarkTest01439 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01439")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map95590 = new java.util.HashMap<String, Object>();
+            map95590.put("keyA-95590", "a_Value"); // put some stuff in the collection
+            map95590.put("keyB-95590", param); // put it in a collection
+            map95590.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map95590.get("keyB-95590"); // get it back out
+            bar = (String) map95590.get("keyA-95590"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01440.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01440.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c819d60d1e5c0fab376f8e4267a3b0340c2399a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01440.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01440")
+public class BenchmarkTest01440 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01440")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01441.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01441.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7d99abf651b290b784b601faecc9240dbcf2cbd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01441.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01441")
+public class BenchmarkTest01441 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01441")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01442.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01442.java
new file mode 100644
index 0000000000000000000000000000000000000000..cdab8e4beec383bf33f51f3ba5dc24939c825b7a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01442.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01442")
+public class BenchmarkTest01442 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01442")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01443.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01443.java
new file mode 100644
index 0000000000000000000000000000000000000000..52e9b1b038f669e83d0ee91d2f9b150b8943bc36
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01443.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01443")
+public class BenchmarkTest01443 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01443")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01444.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01444.java
new file mode 100644
index 0000000000000000000000000000000000000000..a4a6780e4cd0a7b3d16f168f804fd976d1774621
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01444.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01444")
+public class BenchmarkTest01444 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01444")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01445.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01445.java
new file mode 100644
index 0000000000000000000000000000000000000000..78db69057f082e845eaa77c3d95ad9dce50893f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01445.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01445")
+public class BenchmarkTest01445 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01445")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map3083 = new java.util.HashMap<String, Object>();
+            map3083.put("keyA-3083", "a_Value"); // put some stuff in the collection
+            map3083.put("keyB-3083", param); // put it in a collection
+            map3083.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map3083.get("keyB-3083"); // get it back out
+            bar = (String) map3083.get("keyA-3083"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01446.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01446.java
new file mode 100644
index 0000000000000000000000000000000000000000..29b972fdd49d726a2b05115fe5927c4b20abc4df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01446.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01446")
+public class BenchmarkTest01446 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01446")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01447.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01447.java
new file mode 100644
index 0000000000000000000000000000000000000000..cbe6d1f77ae7ed8ba3220ccefd48d46d8ac0478e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01447.java	
@@ -0,0 +1,131 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01447")
+public class BenchmarkTest01447 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01447")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01448.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01448.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd2f8246797f32a9bc5b842adc2f73d28a4dcafe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01448.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01448")
+public class BenchmarkTest01448 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01448")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01449.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01449.java
new file mode 100644
index 0000000000000000000000000000000000000000..978a61f5d4acb810d6e834b75f9bcabaa972a1b8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01449.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01449")
+public class BenchmarkTest01449 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01449")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01450.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01450.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f9ce3f9abb53e5dcaba40fcabf7ffcbab84e204
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01450.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01450")
+public class BenchmarkTest01450 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01450")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map75877 = new java.util.HashMap<String, Object>();
+            map75877.put("keyA-75877", "a_Value"); // put some stuff in the collection
+            map75877.put("keyB-75877", param); // put it in a collection
+            map75877.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map75877.get("keyB-75877"); // get it back out
+            bar = (String) map75877.get("keyA-75877"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01451.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01451.java
new file mode 100644
index 0000000000000000000000000000000000000000..8cb51f969a715a0f95bd4dec996f5320c51d5524
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01451.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01451")
+public class BenchmarkTest01451 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01451")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01452.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01452.java
new file mode 100644
index 0000000000000000000000000000000000000000..107e9b35c1f6b0efb6d177417ceb3c925a29e9c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01452.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01452")
+public class BenchmarkTest01452 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01452")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01453.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01453.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d1d1927d1baad7bb36ced6661cd99eb800a8eb7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01453.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01453")
+public class BenchmarkTest01453 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01453")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01454.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01454.java
new file mode 100644
index 0000000000000000000000000000000000000000..27447afa9c41fc4fb4109801c690916366f671be
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01454.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01454")
+public class BenchmarkTest01454 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01454")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01455.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01455.java
new file mode 100644
index 0000000000000000000000000000000000000000..68e3114044f2322cec418480d63ae4f3a294a581
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01455.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01455")
+public class BenchmarkTest01455 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01455")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01456.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01456.java
new file mode 100644
index 0000000000000000000000000000000000000000..7670ee02be1d2dba98f194d8647bea273a80e1b9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01456.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01456")
+public class BenchmarkTest01456 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01456")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01457.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01457.java
new file mode 100644
index 0000000000000000000000000000000000000000..042a06ceb49116101c34bb71f9f8c6cc8784c15a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01457.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01457")
+public class BenchmarkTest01457 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01457")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01458.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01458.java
new file mode 100644
index 0000000000000000000000000000000000000000..5238666f3cd72fb87f19c5f592ff673dded1c316
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01458.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01458")
+public class BenchmarkTest01458 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01458")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a34936 = param; // assign
+            StringBuilder b34936 = new StringBuilder(a34936); // stick in stringbuilder
+            b34936.append(" SafeStuff"); // append some safe content
+            b34936.replace(
+                    b34936.length() - "Chars".length(),
+                    b34936.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map34936 = new java.util.HashMap<String, Object>();
+            map34936.put("key34936", b34936.toString()); // put in a collection
+            String c34936 = (String) map34936.get("key34936"); // get it back out
+            String d34936 = c34936.substring(0, c34936.length() - 1); // extract most of it
+            String e34936 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d34936.getBytes()))); // B64 encode and decode it
+            String f34936 = e34936.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f34936); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01459.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01459.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3568b99e9a7e4f3f950e394f9f7707c99d67f1f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01459.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01459")
+public class BenchmarkTest01459 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01459")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01460.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01460.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f2be663d53167de0d10e48f69695688d49993a2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01460.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01460")
+public class BenchmarkTest01460 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01460")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map72098 = new java.util.HashMap<String, Object>();
+            map72098.put("keyA-72098", "a-Value"); // put some stuff in the collection
+            map72098.put("keyB-72098", param); // put it in a collection
+            map72098.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map72098.get("keyB-72098"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01461.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01461.java
new file mode 100644
index 0000000000000000000000000000000000000000..da58f508e8585292668ef0385652170b5c91080b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01461.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01461")
+public class BenchmarkTest01461 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01461")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map96401 = new java.util.HashMap<String, Object>();
+            map96401.put("keyA-96401", "a_Value"); // put some stuff in the collection
+            map96401.put("keyB-96401", param); // put it in a collection
+            map96401.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map96401.get("keyB-96401"); // get it back out
+            bar = (String) map96401.get("keyA-96401"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01462.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01462.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea6d0f397c1a6496bcd77c8114a51cce98cca976
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01462.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01462")
+public class BenchmarkTest01462 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01462")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01463.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01463.java
new file mode 100644
index 0000000000000000000000000000000000000000..67a28c020493ba34e29c89394706c1f19c9c20a7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01463.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01463")
+public class BenchmarkTest01463 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01463")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01464.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01464.java
new file mode 100644
index 0000000000000000000000000000000000000000..30616d1503786551f9d5295813408c400a609aa3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01464.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01464")
+public class BenchmarkTest01464 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01464")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01465.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01465.java
new file mode 100644
index 0000000000000000000000000000000000000000..f992008fc3b635d1e028290a94402e39cfb57a39
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01465.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01465")
+public class BenchmarkTest01465 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01465")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01466.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01466.java
new file mode 100644
index 0000000000000000000000000000000000000000..233c2c952da40b069e804c352d507d2c0d5ce1ef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01466.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01466")
+public class BenchmarkTest01466 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01466")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01467.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01467.java
new file mode 100644
index 0000000000000000000000000000000000000000..779a0c6fa281fd23f59ce43d5f376e70a9f326cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01467.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01467")
+public class BenchmarkTest01467 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01467")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map34856 = new java.util.HashMap<String, Object>();
+            map34856.put("keyA-34856", "a_Value"); // put some stuff in the collection
+            map34856.put("keyB-34856", param); // put it in a collection
+            map34856.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map34856.get("keyB-34856"); // get it back out
+            bar = (String) map34856.get("keyA-34856"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01468.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01468.java
new file mode 100644
index 0000000000000000000000000000000000000000..d52d3cb37ee9f0671d002257fb2c1fbd6b7cc417
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01468.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01468")
+public class BenchmarkTest01468 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01468")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01469.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01469.java
new file mode 100644
index 0000000000000000000000000000000000000000..7bcb826ec2332b25488ecd195f46d193d9619566
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01469.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01469")
+public class BenchmarkTest01469 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01469")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a83916 = param; // assign
+            StringBuilder b83916 = new StringBuilder(a83916); // stick in stringbuilder
+            b83916.append(" SafeStuff"); // append some safe content
+            b83916.replace(
+                    b83916.length() - "Chars".length(),
+                    b83916.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map83916 = new java.util.HashMap<String, Object>();
+            map83916.put("key83916", b83916.toString()); // put in a collection
+            String c83916 = (String) map83916.get("key83916"); // get it back out
+            String d83916 = c83916.substring(0, c83916.length() - 1); // extract most of it
+            String e83916 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d83916.getBytes()))); // B64 encode and decode it
+            String f83916 = e83916.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g83916 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g83916); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01470.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01470.java
new file mode 100644
index 0000000000000000000000000000000000000000..c790f4a6590ef4364c20d62b24f14c18dc5c3c93
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01470.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01470")
+public class BenchmarkTest01470 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01470")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01471.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01471.java
new file mode 100644
index 0000000000000000000000000000000000000000..03398c494e0972e1cbb8a810a2dcb92a4d283749
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01471.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01471")
+public class BenchmarkTest01471 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01471")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01472.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01472.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c3b883642e50140fc685af38d4ba7ac2db265df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01472.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01472")
+public class BenchmarkTest01472 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01472")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a60049 = param; // assign
+            StringBuilder b60049 = new StringBuilder(a60049); // stick in stringbuilder
+            b60049.append(" SafeStuff"); // append some safe content
+            b60049.replace(
+                    b60049.length() - "Chars".length(),
+                    b60049.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map60049 = new java.util.HashMap<String, Object>();
+            map60049.put("key60049", b60049.toString()); // put in a collection
+            String c60049 = (String) map60049.get("key60049"); // get it back out
+            String d60049 = c60049.substring(0, c60049.length() - 1); // extract most of it
+            String e60049 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d60049.getBytes()))); // B64 encode and decode it
+            String f60049 = e60049.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g60049 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g60049); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01473.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01473.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d52743ab60e30347efd4bd8a2fbfaa89dd0374a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01473.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01473")
+public class BenchmarkTest01473 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01473")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01474.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01474.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e4fb42d990eaf1cae2108ebcab4552739f24c11
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01474.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01474")
+public class BenchmarkTest01474 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01474")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01475.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01475.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d4a01597bfb6b6de67bc6b0aa1d8a0443ca333e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01475.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01475")
+public class BenchmarkTest01475 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01475")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01476.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01476.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9f70ca5a83a9075a9ce39617fc57bddc51a4a94
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01476.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01476")
+public class BenchmarkTest01476 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01476")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01477.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01477.java
new file mode 100644
index 0000000000000000000000000000000000000000..5bf65678847d75069ce4a3aedc3f060cf16df7f3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01477.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01477")
+public class BenchmarkTest01477 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01477")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01478.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01478.java
new file mode 100644
index 0000000000000000000000000000000000000000..6cf19328db3b04b9f42f88cda4067dab46facb49
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01478.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01478")
+public class BenchmarkTest01478 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01478")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01479.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01479.java
new file mode 100644
index 0000000000000000000000000000000000000000..bca816f781cbe47cb7b3ca0cfc4a306606de9ce4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01479.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01479")
+public class BenchmarkTest01479 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest01479")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01480.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01480.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a3bc4b5bcb6d5be46d0e218f86fb460d08980db
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01480.java	
@@ -0,0 +1,163 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01480")
+public class BenchmarkTest01480 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01480");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a55670 = param; // assign
+            StringBuilder b55670 = new StringBuilder(a55670); // stick in stringbuilder
+            b55670.append(" SafeStuff"); // append some safe content
+            b55670.replace(
+                    b55670.length() - "Chars".length(),
+                    b55670.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map55670 = new java.util.HashMap<String, Object>();
+            map55670.put("key55670", b55670.toString()); // put in a collection
+            String c55670 = (String) map55670.get("key55670"); // get it back out
+            String d55670 = c55670.substring(0, c55670.length() - 1); // extract most of it
+            String e55670 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d55670.getBytes()))); // B64 encode and decode it
+            String f55670 = e55670.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f55670); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01481.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01481.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d54dcb13a5d117815d11688a731d5aec5cc034d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01481.java	
@@ -0,0 +1,150 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01481")
+public class BenchmarkTest01481 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01481");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map69587 = new java.util.HashMap<String, Object>();
+            map69587.put("keyA-69587", "a_Value"); // put some stuff in the collection
+            map69587.put("keyB-69587", param); // put it in a collection
+            map69587.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map69587.get("keyB-69587"); // get it back out
+            bar = (String) map69587.get("keyA-69587"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01482.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01482.java
new file mode 100644
index 0000000000000000000000000000000000000000..8251f9abae61c5e4d54f242e4b047d5da5c580e4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01482.java	
@@ -0,0 +1,163 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01482")
+public class BenchmarkTest01482 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01482");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01483.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01483.java
new file mode 100644
index 0000000000000000000000000000000000000000..24e44140c340f98819c9fe12cd4936a7ee6bfeaa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01483.java	
@@ -0,0 +1,157 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01483")
+public class BenchmarkTest01483 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01483");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01484.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01484.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c201c7a223f310cdf1a1e03decc21d3a2c45159
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01484.java	
@@ -0,0 +1,148 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01484")
+public class BenchmarkTest01484 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01484");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01485.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01485.java
new file mode 100644
index 0000000000000000000000000000000000000000..5fb1b4dfa1e1a8695ff5c6f057015b387c578c20
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01485.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01485")
+public class BenchmarkTest01485 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01485");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01486.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01486.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e9e57589bee628381021b3db4439a245c007d6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01486.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01486")
+public class BenchmarkTest01486 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01486");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01487.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01487.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae9c70652520ac7a9e37340a8efe24bc1168ed0a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01487.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01487")
+public class BenchmarkTest01487 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01487");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map78614 = new java.util.HashMap<String, Object>();
+            map78614.put("keyA-78614", "a_Value"); // put some stuff in the collection
+            map78614.put("keyB-78614", param); // put it in a collection
+            map78614.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map78614.get("keyB-78614"); // get it back out
+            bar = (String) map78614.get("keyA-78614"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01488.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01488.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8537854e576813e3e023bb984518ab008665cf2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01488.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01488")
+public class BenchmarkTest01488 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01488");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01489.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01489.java
new file mode 100644
index 0000000000000000000000000000000000000000..fbe43c30ea2db53e6cc0b23a22da8b1a3a17c78e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01489.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01489")
+public class BenchmarkTest01489 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01489");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01490.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01490.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9f9c49234855452941efe59403ed937194095a8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01490.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01490")
+public class BenchmarkTest01490 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01490");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map58491 = new java.util.HashMap<String, Object>();
+            map58491.put("keyA-58491", "a-Value"); // put some stuff in the collection
+            map58491.put("keyB-58491", param); // put it in a collection
+            map58491.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map58491.get("keyB-58491"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01491.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01491.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b6130703e6b9ad0d18af7f400a3652b493f7a66
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01491.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01491")
+public class BenchmarkTest01491 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01491");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a55812 = param; // assign
+            StringBuilder b55812 = new StringBuilder(a55812); // stick in stringbuilder
+            b55812.append(" SafeStuff"); // append some safe content
+            b55812.replace(
+                    b55812.length() - "Chars".length(),
+                    b55812.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map55812 = new java.util.HashMap<String, Object>();
+            map55812.put("key55812", b55812.toString()); // put in a collection
+            String c55812 = (String) map55812.get("key55812"); // get it back out
+            String d55812 = c55812.substring(0, c55812.length() - 1); // extract most of it
+            String e55812 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d55812.getBytes()))); // B64 encode and decode it
+            String f55812 = e55812.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g55812 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g55812); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01492.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01492.java
new file mode 100644
index 0000000000000000000000000000000000000000..4012329a382a6cd51bea48133efe920fbaa875fe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01492.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01492")
+public class BenchmarkTest01492 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01492");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01493.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01493.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fbfae262034d74795d5f9fbcfe4413562450662
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01493.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01493")
+public class BenchmarkTest01493 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01493");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map71009 = new java.util.HashMap<String, Object>();
+            map71009.put("keyA-71009", "a_Value"); // put some stuff in the collection
+            map71009.put("keyB-71009", param); // put it in a collection
+            map71009.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map71009.get("keyB-71009"); // get it back out
+            bar = (String) map71009.get("keyA-71009"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01494.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01494.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d0aec60e76979ae3e41c374f1db00c94d4f35a8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01494.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01494")
+public class BenchmarkTest01494 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01494");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01495.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01495.java
new file mode 100644
index 0000000000000000000000000000000000000000..79a8fb3658f95f6de2330b6d598645f0953ee111
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01495.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01495")
+public class BenchmarkTest01495 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01495");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01496.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01496.java
new file mode 100644
index 0000000000000000000000000000000000000000..d58cb2ff7a3e0f67f1ddfa08565e6fcb3cde6fd3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01496.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01496")
+public class BenchmarkTest01496 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01496");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01497.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01497.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea80b32f3fc4e17977726b375fbbe78c109ec4f5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01497.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01497")
+public class BenchmarkTest01497 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01497");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01498.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01498.java
new file mode 100644
index 0000000000000000000000000000000000000000..e086b9a4530fa8a7cdbc5ccc508ddb390cc35f94
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01498.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01498")
+public class BenchmarkTest01498 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01498");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01499.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01499.java
new file mode 100644
index 0000000000000000000000000000000000000000..134f0602cecd39ca0d0562fdc0a9378c6fc52c8f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01499.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01499")
+public class BenchmarkTest01499 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01499");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01500.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01500.java
new file mode 100644
index 0000000000000000000000000000000000000000..dbbe2724681fe7e80968dda4a34904668c56f593
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01500.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01500")
+public class BenchmarkTest01500 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01500");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map3545 = new java.util.HashMap<String, Object>();
+            map3545.put("keyA-3545", "a-Value"); // put some stuff in the collection
+            map3545.put("keyB-3545", param); // put it in a collection
+            map3545.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map3545.get("keyB-3545"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01501.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01501.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c4bfce534ed4fdfdb754185cf3dadbae64489cd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01501.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01501")
+public class BenchmarkTest01501 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01501");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01502.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01502.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d70d226f327893eae6c78b5f0e17b70ee2a001d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01502.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01502")
+public class BenchmarkTest01502 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01502");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a43640 = param; // assign
+            StringBuilder b43640 = new StringBuilder(a43640); // stick in stringbuilder
+            b43640.append(" SafeStuff"); // append some safe content
+            b43640.replace(
+                    b43640.length() - "Chars".length(),
+                    b43640.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map43640 = new java.util.HashMap<String, Object>();
+            map43640.put("key43640", b43640.toString()); // put in a collection
+            String c43640 = (String) map43640.get("key43640"); // get it back out
+            String d43640 = c43640.substring(0, c43640.length() - 1); // extract most of it
+            String e43640 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d43640.getBytes()))); // B64 encode and decode it
+            String f43640 = e43640.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g43640 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g43640); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01503.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01503.java
new file mode 100644
index 0000000000000000000000000000000000000000..e20da0e8af8bd5ec746c4011d15e539fba85ef64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01503.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01503")
+public class BenchmarkTest01503 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01503");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01504.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01504.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e91d2bdb3a5135bf82d5ecec5246b6de11d20a3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01504.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01504")
+public class BenchmarkTest01504 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01504");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01505.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01505.java
new file mode 100644
index 0000000000000000000000000000000000000000..9fa70a5dffe0047f9cb3c8928826f93b681b704d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01505.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01505")
+public class BenchmarkTest01505 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01505");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01506.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01506.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8af7af6631f6ee6ff5fa9a1e412a7b31c9c554c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01506.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01506")
+public class BenchmarkTest01506 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01506");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01507.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01507.java
new file mode 100644
index 0000000000000000000000000000000000000000..70680d1194899aa58811fc8453c193be1e5c6c36
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01507.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01507")
+public class BenchmarkTest01507 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01507");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01508.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01508.java
new file mode 100644
index 0000000000000000000000000000000000000000..4939385f5fd4763b33e181bacc24bb61c1681cb7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01508.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-02/BenchmarkTest01508")
+public class BenchmarkTest01508 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01508");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01509.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01509.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6d433b19aef49fc23c533f1083edd2e901670a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01509.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01509")
+public class BenchmarkTest01509 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01509");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01510.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01510.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ba33055e25f3f8827f854520b10d888168f85fe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01510.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01510")
+public class BenchmarkTest01510 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01510");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01511.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01511.java
new file mode 100644
index 0000000000000000000000000000000000000000..e517b726b4c051e4d3a2929fee6bdd686bb01635
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01511.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01511")
+public class BenchmarkTest01511 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01511");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01512.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01512.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e38d7be54f45bd29cd712bc72ba5801f42916a6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01512.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01512")
+public class BenchmarkTest01512 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01512");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz76583 = new StringBuilder(param);
+                bar =
+                        sbxyz76583
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01513.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01513.java
new file mode 100644
index 0000000000000000000000000000000000000000..fba979e3c546172ec863765d7e61335b6ae23d93
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01513.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01513")
+public class BenchmarkTest01513 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01513");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01514.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01514.java
new file mode 100644
index 0000000000000000000000000000000000000000..72d91e8bdf6f5b1205662ee3c5e83bdadf8822f9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01514.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01514")
+public class BenchmarkTest01514 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01514");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map56316 = new java.util.HashMap<String, Object>();
+            map56316.put("keyA-56316", "a_Value"); // put some stuff in the collection
+            map56316.put("keyB-56316", param); // put it in a collection
+            map56316.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map56316.get("keyB-56316"); // get it back out
+            bar = (String) map56316.get("keyA-56316"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01515.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01515.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc84bbc2f9fd9945c2e8ccc1e2c524b31755b788
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01515.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01515")
+public class BenchmarkTest01515 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01515");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a84124 = param; // assign
+            StringBuilder b84124 = new StringBuilder(a84124); // stick in stringbuilder
+            b84124.append(" SafeStuff"); // append some safe content
+            b84124.replace(
+                    b84124.length() - "Chars".length(),
+                    b84124.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map84124 = new java.util.HashMap<String, Object>();
+            map84124.put("key84124", b84124.toString()); // put in a collection
+            String c84124 = (String) map84124.get("key84124"); // get it back out
+            String d84124 = c84124.substring(0, c84124.length() - 1); // extract most of it
+            String e84124 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d84124.getBytes()))); // B64 encode and decode it
+            String f84124 = e84124.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g84124 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g84124); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01516.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01516.java
new file mode 100644
index 0000000000000000000000000000000000000000..327c955fd9e9cb8f6fe1c802ca455b1e75a628d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01516.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01516")
+public class BenchmarkTest01516 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01516");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a84214 = param; // assign
+            StringBuilder b84214 = new StringBuilder(a84214); // stick in stringbuilder
+            b84214.append(" SafeStuff"); // append some safe content
+            b84214.replace(
+                    b84214.length() - "Chars".length(),
+                    b84214.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map84214 = new java.util.HashMap<String, Object>();
+            map84214.put("key84214", b84214.toString()); // put in a collection
+            String c84214 = (String) map84214.get("key84214"); // get it back out
+            String d84214 = c84214.substring(0, c84214.length() - 1); // extract most of it
+            String e84214 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d84214.getBytes()))); // B64 encode and decode it
+            String f84214 = e84214.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g84214 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g84214); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01517.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01517.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3aad6ea571790d14b5b7527ae453a9344933fc8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01517.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01517")
+public class BenchmarkTest01517 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01517");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01518.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01518.java
new file mode 100644
index 0000000000000000000000000000000000000000..a003fa81140eb1d83a2a44f7b29c4e606c80b74e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01518.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01518")
+public class BenchmarkTest01518 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01518");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a96602 = param; // assign
+            StringBuilder b96602 = new StringBuilder(a96602); // stick in stringbuilder
+            b96602.append(" SafeStuff"); // append some safe content
+            b96602.replace(
+                    b96602.length() - "Chars".length(),
+                    b96602.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map96602 = new java.util.HashMap<String, Object>();
+            map96602.put("key96602", b96602.toString()); // put in a collection
+            String c96602 = (String) map96602.get("key96602"); // get it back out
+            String d96602 = c96602.substring(0, c96602.length() - 1); // extract most of it
+            String e96602 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d96602.getBytes()))); // B64 encode and decode it
+            String f96602 = e96602.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f96602); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01519.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01519.java
new file mode 100644
index 0000000000000000000000000000000000000000..c88fa93cb7889e20a1f89ce348db404fa6b04451
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01519.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01519")
+public class BenchmarkTest01519 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01519");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz3774 = new StringBuilder(param);
+                bar =
+                        sbxyz3774
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01520.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01520.java
new file mode 100644
index 0000000000000000000000000000000000000000..e846d48201cac24db7147a6398c42bd43348d02d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01520.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01520")
+public class BenchmarkTest01520 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01520");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map44642 = new java.util.HashMap<String, Object>();
+            map44642.put("keyA-44642", "a_Value"); // put some stuff in the collection
+            map44642.put("keyB-44642", param); // put it in a collection
+            map44642.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map44642.get("keyB-44642"); // get it back out
+            bar = (String) map44642.get("keyA-44642"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01521.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01521.java
new file mode 100644
index 0000000000000000000000000000000000000000..0592c2e4b00728337f6a276e3b24d182176e4ba2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01521.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01521")
+public class BenchmarkTest01521 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01521");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01522.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01522.java
new file mode 100644
index 0000000000000000000000000000000000000000..1197e8d4ca2c3948ea44020cfd2aea27c91565a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01522.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01522")
+public class BenchmarkTest01522 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01522");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01523.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01523.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b3a9a55be066ba0f7a848fc3d0624895d2e408f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01523.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01523")
+public class BenchmarkTest01523 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01523");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a94015 = param; // assign
+            StringBuilder b94015 = new StringBuilder(a94015); // stick in stringbuilder
+            b94015.append(" SafeStuff"); // append some safe content
+            b94015.replace(
+                    b94015.length() - "Chars".length(),
+                    b94015.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map94015 = new java.util.HashMap<String, Object>();
+            map94015.put("key94015", b94015.toString()); // put in a collection
+            String c94015 = (String) map94015.get("key94015"); // get it back out
+            String d94015 = c94015.substring(0, c94015.length() - 1); // extract most of it
+            String e94015 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d94015.getBytes()))); // B64 encode and decode it
+            String f94015 = e94015.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f94015); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01524.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01524.java
new file mode 100644
index 0000000000000000000000000000000000000000..b273c776c94deaa9859d8a5a0027f306e6f61d21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01524.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01524")
+public class BenchmarkTest01524 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01524");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01525.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01525.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b40bb847b6e4763ee7d6baf6a8323ec2a91dbb3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01525.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01525")
+public class BenchmarkTest01525 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01525");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz67457 = new StringBuilder(param);
+                bar =
+                        sbxyz67457
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01526.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01526.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ccadace350ed3f954bd47f74eff7beffd5aa682
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01526.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01526")
+public class BenchmarkTest01526 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01526");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01527.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01527.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1a36f41f644f8fe1ad685309d029734e0526a1f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01527.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01527")
+public class BenchmarkTest01527 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01527");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01528.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01528.java
new file mode 100644
index 0000000000000000000000000000000000000000..bba30eb8b02312124f8f72d527cd6eb0dfa04636
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01528.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01528")
+public class BenchmarkTest01528 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01528");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01529.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01529.java
new file mode 100644
index 0000000000000000000000000000000000000000..7dfb543deb0c39eeab3a17b4d09cda32a55f00ea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01529.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01529")
+public class BenchmarkTest01529 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01529");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01530.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01530.java
new file mode 100644
index 0000000000000000000000000000000000000000..6cbc67e12ef01db388c54ce4b19572422d36ce2f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01530.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01530")
+public class BenchmarkTest01530 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01530");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01531.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01531.java
new file mode 100644
index 0000000000000000000000000000000000000000..936b20bab1b3d82729c3c04e454675585c4edd36
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01531.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01531")
+public class BenchmarkTest01531 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01531");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01532.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01532.java
new file mode 100644
index 0000000000000000000000000000000000000000..afd6a7bccef741e1ce7cf6159c14d9bea16aea95
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01532.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01532")
+public class BenchmarkTest01532 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01532");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01533.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01533.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc95e14f00fae7defffc51843acf3f59a436f776
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01533.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01533")
+public class BenchmarkTest01533 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01533");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01534.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01534.java
new file mode 100644
index 0000000000000000000000000000000000000000..58ad10f6d96dbe03ca251c4a316bb64cf3eb5d15
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01534.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01534")
+public class BenchmarkTest01534 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01534");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01535.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01535.java
new file mode 100644
index 0000000000000000000000000000000000000000..a056450cfdcad887b34ac3869febaa928021affe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01535.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01535")
+public class BenchmarkTest01535 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01535");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01536.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01536.java
new file mode 100644
index 0000000000000000000000000000000000000000..dfc1dddff4993e278817cc6f35335964f830b4f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01536.java	
@@ -0,0 +1,121 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01536")
+public class BenchmarkTest01536 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01536");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a79311 = param; // assign
+            StringBuilder b79311 = new StringBuilder(a79311); // stick in stringbuilder
+            b79311.append(" SafeStuff"); // append some safe content
+            b79311.replace(
+                    b79311.length() - "Chars".length(),
+                    b79311.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map79311 = new java.util.HashMap<String, Object>();
+            map79311.put("key79311", b79311.toString()); // put in a collection
+            String c79311 = (String) map79311.get("key79311"); // get it back out
+            String d79311 = c79311.substring(0, c79311.length() - 1); // extract most of it
+            String e79311 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d79311.getBytes()))); // B64 encode and decode it
+            String f79311 = e79311.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g79311 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g79311); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01537.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01537.java
new file mode 100644
index 0000000000000000000000000000000000000000..76fcba32ef15f1369282b6e21f994c9e06f38731
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01537.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01537")
+public class BenchmarkTest01537 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01537");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map7472 = new java.util.HashMap<String, Object>();
+            map7472.put("keyA-7472", "a_Value"); // put some stuff in the collection
+            map7472.put("keyB-7472", param); // put it in a collection
+            map7472.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map7472.get("keyB-7472"); // get it back out
+            bar = (String) map7472.get("keyA-7472"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01538.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01538.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e4b6357c57854b7a1d384156f130a206857bbc6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01538.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01538")
+public class BenchmarkTest01538 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01538");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map82396 = new java.util.HashMap<String, Object>();
+            map82396.put("keyA-82396", "a_Value"); // put some stuff in the collection
+            map82396.put("keyB-82396", param); // put it in a collection
+            map82396.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map82396.get("keyB-82396"); // get it back out
+            bar = (String) map82396.get("keyA-82396"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01539.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01539.java
new file mode 100644
index 0000000000000000000000000000000000000000..9265806e3ed4737d1eab066d5e17fdddbdec062f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01539.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01539")
+public class BenchmarkTest01539 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01539");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01540.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01540.java
new file mode 100644
index 0000000000000000000000000000000000000000..a323702ea2c1b1f23a25c67c5107d85076e32f77
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01540.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01540")
+public class BenchmarkTest01540 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01540");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01541.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01541.java
new file mode 100644
index 0000000000000000000000000000000000000000..aff80df4a49edccf44788abb8fb4741d7130f9ff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01541.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01541")
+public class BenchmarkTest01541 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01541");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01542.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01542.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d4d397f058196202bb554b8ff7e907e408c4e93
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01542.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01542")
+public class BenchmarkTest01542 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01542");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map98601 = new java.util.HashMap<String, Object>();
+            map98601.put("keyA-98601", "a-Value"); // put some stuff in the collection
+            map98601.put("keyB-98601", param); // put it in a collection
+            map98601.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map98601.get("keyB-98601"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01543.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01543.java
new file mode 100644
index 0000000000000000000000000000000000000000..a86c61f1792043cad1da79beb7f07720c961b4fc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01543.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01543")
+public class BenchmarkTest01543 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01543");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01544.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01544.java
new file mode 100644
index 0000000000000000000000000000000000000000..eaed244d4ad7ef1be144dbc81769a682de5c3c68
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01544.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01544")
+public class BenchmarkTest01544 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01544");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01545.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01545.java
new file mode 100644
index 0000000000000000000000000000000000000000..c579f6d2802e563b297df95ba55bad5eaa3a6b2b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01545.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01545")
+public class BenchmarkTest01545 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01545");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a43050 = param; // assign
+            StringBuilder b43050 = new StringBuilder(a43050); // stick in stringbuilder
+            b43050.append(" SafeStuff"); // append some safe content
+            b43050.replace(
+                    b43050.length() - "Chars".length(),
+                    b43050.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map43050 = new java.util.HashMap<String, Object>();
+            map43050.put("key43050", b43050.toString()); // put in a collection
+            String c43050 = (String) map43050.get("key43050"); // get it back out
+            String d43050 = c43050.substring(0, c43050.length() - 1); // extract most of it
+            String e43050 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d43050.getBytes()))); // B64 encode and decode it
+            String f43050 = e43050.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g43050 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g43050); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01546.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01546.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f28edb3a3c5e01cec94d1c407a1ff42ed8af3d9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01546.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01546")
+public class BenchmarkTest01546 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01546");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01547.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01547.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8f16ac7385c3ac6ff1864e045c8a785c72f9850
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01547.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01547")
+public class BenchmarkTest01547 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01547");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01548.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01548.java
new file mode 100644
index 0000000000000000000000000000000000000000..15cdc1038e2b5a7fd3336a5c393278e9f63b05d2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01548.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01548")
+public class BenchmarkTest01548 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01548");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01549.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01549.java
new file mode 100644
index 0000000000000000000000000000000000000000..883855e9c6d3cc0538d40e6fadfc7b55dbd18c45
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01549.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01549")
+public class BenchmarkTest01549 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01549");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01550.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01550.java
new file mode 100644
index 0000000000000000000000000000000000000000..44430eaf29c6019a2bb8c4d59e1517049a482e48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01550.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01550")
+public class BenchmarkTest01550 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01550");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a86153 = param; // assign
+            StringBuilder b86153 = new StringBuilder(a86153); // stick in stringbuilder
+            b86153.append(" SafeStuff"); // append some safe content
+            b86153.replace(
+                    b86153.length() - "Chars".length(),
+                    b86153.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map86153 = new java.util.HashMap<String, Object>();
+            map86153.put("key86153", b86153.toString()); // put in a collection
+            String c86153 = (String) map86153.get("key86153"); // get it back out
+            String d86153 = c86153.substring(0, c86153.length() - 1); // extract most of it
+            String e86153 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d86153.getBytes()))); // B64 encode and decode it
+            String f86153 = e86153.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f86153); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01551.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01551.java
new file mode 100644
index 0000000000000000000000000000000000000000..332ac96b90e83017a27e3ed3fd2a42d9d7683152
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01551.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01551")
+public class BenchmarkTest01551 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01551");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz68516 = new StringBuilder(param);
+            String bar = sbxyz68516.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01552.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01552.java
new file mode 100644
index 0000000000000000000000000000000000000000..eae8b2b9be7acf79766ad61b2c919f4a0afe11ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01552.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01552")
+public class BenchmarkTest01552 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01552");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01553.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01553.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5899ccc318aac0aa96a4f90ee373068d1cb8211
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01553.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01553")
+public class BenchmarkTest01553 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01553");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map99501 = new java.util.HashMap<String, Object>();
+            map99501.put("keyA-99501", "a_Value"); // put some stuff in the collection
+            map99501.put("keyB-99501", param); // put it in a collection
+            map99501.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map99501.get("keyB-99501"); // get it back out
+            bar = (String) map99501.get("keyA-99501"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01554.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01554.java
new file mode 100644
index 0000000000000000000000000000000000000000..369d79ff3b3e3f4c7d4d2fbef560596d75e51294
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01554.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01554")
+public class BenchmarkTest01554 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01554");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01555.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01555.java
new file mode 100644
index 0000000000000000000000000000000000000000..44ef3c87cfaaec55cbe78531e64b1d1c66b6f359
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01555.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01555")
+public class BenchmarkTest01555 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01555");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01556.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01556.java
new file mode 100644
index 0000000000000000000000000000000000000000..21f111b23e5a047a19ff758d5eb8cdba15c14b63
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01556.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01556")
+public class BenchmarkTest01556 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01556");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01557.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01557.java
new file mode 100644
index 0000000000000000000000000000000000000000..88dc9f53ac8a42e29d27ab97b82249ecf7e84b06
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01557.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01557")
+public class BenchmarkTest01557 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01557");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map20581 = new java.util.HashMap<String, Object>();
+            map20581.put("keyA-20581", "a-Value"); // put some stuff in the collection
+            map20581.put("keyB-20581", param); // put it in a collection
+            map20581.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map20581.get("keyB-20581"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01558.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01558.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4707c9a1468bf42a68776eafbd7281240d2647b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01558.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01558")
+public class BenchmarkTest01558 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01558");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01559.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01559.java
new file mode 100644
index 0000000000000000000000000000000000000000..db816bcf45bee83e45707a912d3b0574c67937ae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01559.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01559")
+public class BenchmarkTest01559 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01559");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map31651 = new java.util.HashMap<String, Object>();
+            map31651.put("keyA-31651", "a-Value"); // put some stuff in the collection
+            map31651.put("keyB-31651", param); // put it in a collection
+            map31651.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map31651.get("keyB-31651"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01560.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01560.java
new file mode 100644
index 0000000000000000000000000000000000000000..3dc68f652d032025764f66f2fd52bc8788b1466b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01560.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01560")
+public class BenchmarkTest01560 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01560");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01561.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01561.java
new file mode 100644
index 0000000000000000000000000000000000000000..522ed6a8fb8521fa2f5479abfb61cd129a0d89e9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01561.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01561")
+public class BenchmarkTest01561 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01561");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01562.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01562.java
new file mode 100644
index 0000000000000000000000000000000000000000..c71a3cce032b8e4f78cd3ec3e5513a827f632659
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01562.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01562")
+public class BenchmarkTest01562 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest01562");
+        if (param == null) param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01563.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01563.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff02a84a1f60928766962ad3e8f8de97b7cfb877
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01563.java	
@@ -0,0 +1,146 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01563")
+public class BenchmarkTest01563 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01563");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01564.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01564.java
new file mode 100644
index 0000000000000000000000000000000000000000..f9ad30de76e4c378a619af37015a3bbd46d60154
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01564.java	
@@ -0,0 +1,144 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01564")
+public class BenchmarkTest01564 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01564");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01565.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01565.java
new file mode 100644
index 0000000000000000000000000000000000000000..1db1a5d7477d25db20db206dab6133fe70bdca34
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01565.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01565")
+public class BenchmarkTest01565 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01565");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01566.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01566.java
new file mode 100644
index 0000000000000000000000000000000000000000..af79e767b3ff2e0162172f356102963a79218700
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01566.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01566")
+public class BenchmarkTest01566 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01566");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01567.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01567.java
new file mode 100644
index 0000000000000000000000000000000000000000..da2bf4e1975d1914ff68f64ec6c22ff4d1aca4ff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01567.java	
@@ -0,0 +1,135 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-01/BenchmarkTest01567")
+public class BenchmarkTest01567 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01567");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a29366 = param; // assign
+            StringBuilder b29366 = new StringBuilder(a29366); // stick in stringbuilder
+            b29366.append(" SafeStuff"); // append some safe content
+            b29366.replace(
+                    b29366.length() - "Chars".length(),
+                    b29366.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map29366 = new java.util.HashMap<String, Object>();
+            map29366.put("key29366", b29366.toString()); // put in a collection
+            String c29366 = (String) map29366.get("key29366"); // get it back out
+            String d29366 = c29366.substring(0, c29366.length() - 1); // extract most of it
+            String e29366 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d29366.getBytes()))); // B64 encode and decode it
+            String f29366 = e29366.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g29366 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g29366); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01568.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01568.java
new file mode 100644
index 0000000000000000000000000000000000000000..a4e25b60b67ef4d176d20686971d72ea42fc5872
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01568.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01568")
+public class BenchmarkTest01568 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01568");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01569.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01569.java
new file mode 100644
index 0000000000000000000000000000000000000000..f305c8ee362534bedd053af2ee23f08ccd98a39a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01569.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01569")
+public class BenchmarkTest01569 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01569");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a75250 = param; // assign
+            StringBuilder b75250 = new StringBuilder(a75250); // stick in stringbuilder
+            b75250.append(" SafeStuff"); // append some safe content
+            b75250.replace(
+                    b75250.length() - "Chars".length(),
+                    b75250.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map75250 = new java.util.HashMap<String, Object>();
+            map75250.put("key75250", b75250.toString()); // put in a collection
+            String c75250 = (String) map75250.get("key75250"); // get it back out
+            String d75250 = c75250.substring(0, c75250.length() - 1); // extract most of it
+            String e75250 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d75250.getBytes()))); // B64 encode and decode it
+            String f75250 = e75250.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g75250 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g75250); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01570.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01570.java
new file mode 100644
index 0000000000000000000000000000000000000000..39337c5bd2e33232c2f0ea6235f17a2790cf6fbe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01570.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01570")
+public class BenchmarkTest01570 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01570");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01571.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01571.java
new file mode 100644
index 0000000000000000000000000000000000000000..060980e3a3d11f2884dd474e36dab7d0ab50d001
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01571.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01571")
+public class BenchmarkTest01571 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01571");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01572.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01572.java
new file mode 100644
index 0000000000000000000000000000000000000000..35a95c1cece9da20c686bcd6171305e72b822da7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01572.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01572")
+public class BenchmarkTest01572 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01572");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01573.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01573.java
new file mode 100644
index 0000000000000000000000000000000000000000..8665aad19e77bf5a333aea8d9123631c304650e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01573.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01573")
+public class BenchmarkTest01573 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01573");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01574.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01574.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5e4b815b5cbd2c0a7d1cceded687e964dccb17a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01574.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01574")
+public class BenchmarkTest01574 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01574");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map48244 = new java.util.HashMap<String, Object>();
+            map48244.put("keyA-48244", "a_Value"); // put some stuff in the collection
+            map48244.put("keyB-48244", param); // put it in a collection
+            map48244.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map48244.get("keyB-48244"); // get it back out
+            bar = (String) map48244.get("keyA-48244"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01575.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01575.java
new file mode 100644
index 0000000000000000000000000000000000000000..78f1c3e2d63cbed133dec2a715ecc7439032103c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01575.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01575")
+public class BenchmarkTest01575 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01575");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01576.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01576.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a6e5b5feb5710c1b5af05bdb7668f901a2e7bd7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01576.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01576")
+public class BenchmarkTest01576 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01576");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01577.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01577.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e15cf3532ad4275fe1983c2ae0eb0fb915770c9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01577.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01577")
+public class BenchmarkTest01577 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01577");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01578.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01578.java
new file mode 100644
index 0000000000000000000000000000000000000000..9fdb2e98b8552e4daa46ad6bb1d871b554240748
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01578.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01578")
+public class BenchmarkTest01578 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01578");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz85952 = new StringBuilder(param);
+            String bar = sbxyz85952.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01579.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01579.java
new file mode 100644
index 0000000000000000000000000000000000000000..14fd6182ebdca775a91ff68ac6a741b405e2e8a2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01579.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01579")
+public class BenchmarkTest01579 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01579");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01580.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01580.java
new file mode 100644
index 0000000000000000000000000000000000000000..d12aa1cabe6c1e7fc8b9638c0966372184e4afb4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01580.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01580")
+public class BenchmarkTest01580 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01580");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01581.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01581.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a4532c78cbe0c79543b52af97f369b725ea9547
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01581.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01581")
+public class BenchmarkTest01581 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01581");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01582.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01582.java
new file mode 100644
index 0000000000000000000000000000000000000000..1fc64d8c2a90de1e47441d7117c820b994c030c4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01582.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01582")
+public class BenchmarkTest01582 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01582");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map17367 = new java.util.HashMap<String, Object>();
+            map17367.put("keyA-17367", "a_Value"); // put some stuff in the collection
+            map17367.put("keyB-17367", param); // put it in a collection
+            map17367.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map17367.get("keyB-17367"); // get it back out
+            bar = (String) map17367.get("keyA-17367"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01583.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01583.java
new file mode 100644
index 0000000000000000000000000000000000000000..439093bb2d90ce1f42bb5619e7ef0ada17fc0785
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01583.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01583")
+public class BenchmarkTest01583 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01583");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz82559 = new StringBuilder(param);
+            String bar = sbxyz82559.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01584.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01584.java
new file mode 100644
index 0000000000000000000000000000000000000000..7604793804e5fba65beec64f9a9a78bfbea8d608
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01584.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01584")
+public class BenchmarkTest01584 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01584");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01585.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01585.java
new file mode 100644
index 0000000000000000000000000000000000000000..83e4f9807c0a540782548a6503e6b572fb6a73cd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01585.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01585")
+public class BenchmarkTest01585 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01585");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01586.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01586.java
new file mode 100644
index 0000000000000000000000000000000000000000..40dd5c85d2e2be4f9ec161cbebbfe88034724d51
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01586.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01586")
+public class BenchmarkTest01586 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01586");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01587.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01587.java
new file mode 100644
index 0000000000000000000000000000000000000000..a03c66092f4397a1b1e89966b8669c853bdc8795
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01587.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01587")
+public class BenchmarkTest01587 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01587");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01588.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01588.java
new file mode 100644
index 0000000000000000000000000000000000000000..1b9713e7ec4d502f22c80a0a155dec3e3eee4420
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01588.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01588")
+public class BenchmarkTest01588 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01588");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01589.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01589.java
new file mode 100644
index 0000000000000000000000000000000000000000..825132b1e032f314a7f3d6bf9e464c20d171426f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01589.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01589")
+public class BenchmarkTest01589 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01589");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01590.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01590.java
new file mode 100644
index 0000000000000000000000000000000000000000..3fcb3d97c8c5eba6873b8968417a49d4af565466
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01590.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01590")
+public class BenchmarkTest01590 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01590");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01591.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01591.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f1ce3cf3eb45d3f01d1a34466d0e492b7d88633
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01591.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01591")
+public class BenchmarkTest01591 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01591");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a1207 = param; // assign
+            StringBuilder b1207 = new StringBuilder(a1207); // stick in stringbuilder
+            b1207.append(" SafeStuff"); // append some safe content
+            b1207.replace(
+                    b1207.length() - "Chars".length(),
+                    b1207.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map1207 = new java.util.HashMap<String, Object>();
+            map1207.put("key1207", b1207.toString()); // put in a collection
+            String c1207 = (String) map1207.get("key1207"); // get it back out
+            String d1207 = c1207.substring(0, c1207.length() - 1); // extract most of it
+            String e1207 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d1207.getBytes()))); // B64 encode and decode it
+            String f1207 = e1207.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g1207 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g1207); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01592.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01592.java
new file mode 100644
index 0000000000000000000000000000000000000000..9809a911e5b81ea954ff6e1642be4c57e9547b10
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01592.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01592")
+public class BenchmarkTest01592 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01592");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01593.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01593.java
new file mode 100644
index 0000000000000000000000000000000000000000..96e22ac7a30c747277af7fc358960184a73bc9c0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01593.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01593")
+public class BenchmarkTest01593 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01593");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01594.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01594.java
new file mode 100644
index 0000000000000000000000000000000000000000..b277e914d1a4a40e97e9e144bf53a257b484b669
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01594.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01594")
+public class BenchmarkTest01594 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01594");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz51154 = new StringBuilder(param);
+            String bar = sbxyz51154.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01595.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01595.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf2b90243f179826c6d55db23bac5807fe752eeb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01595.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01595")
+public class BenchmarkTest01595 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01595");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01596.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01596.java
new file mode 100644
index 0000000000000000000000000000000000000000..52142ef32a14938213a554904fcc3e22754cc99c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01596.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01596")
+public class BenchmarkTest01596 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01596");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01597.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01597.java
new file mode 100644
index 0000000000000000000000000000000000000000..32e985942d93b028c10bc8147a3f428ae643b921
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01597.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01597")
+public class BenchmarkTest01597 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01597");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz81751 = new StringBuilder(param);
+            String bar = sbxyz81751.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01598.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01598.java
new file mode 100644
index 0000000000000000000000000000000000000000..2faeedb43b3d25785a0be17359b982bf15c32f6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01598.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01598")
+public class BenchmarkTest01598 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01598");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a75770 = param; // assign
+            StringBuilder b75770 = new StringBuilder(a75770); // stick in stringbuilder
+            b75770.append(" SafeStuff"); // append some safe content
+            b75770.replace(
+                    b75770.length() - "Chars".length(),
+                    b75770.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map75770 = new java.util.HashMap<String, Object>();
+            map75770.put("key75770", b75770.toString()); // put in a collection
+            String c75770 = (String) map75770.get("key75770"); // get it back out
+            String d75770 = c75770.substring(0, c75770.length() - 1); // extract most of it
+            String e75770 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d75770.getBytes()))); // B64 encode and decode it
+            String f75770 = e75770.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f75770); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01599.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01599.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b9392a4c93846dd78a3cce8df6b12be6bc780bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01599.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01599")
+public class BenchmarkTest01599 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01599");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map20521 = new java.util.HashMap<String, Object>();
+            map20521.put("keyA-20521", "a_Value"); // put some stuff in the collection
+            map20521.put("keyB-20521", param); // put it in a collection
+            map20521.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map20521.get("keyB-20521"); // get it back out
+            bar = (String) map20521.get("keyA-20521"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01600.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01600.java
new file mode 100644
index 0000000000000000000000000000000000000000..09c343c98460534076866e0cd77b662eddaf1f90
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01600.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01600")
+public class BenchmarkTest01600 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01600");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01601.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01601.java
new file mode 100644
index 0000000000000000000000000000000000000000..4b4a4525078dd1c7ee1aec887547c861cea41c56
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01601.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01601")
+public class BenchmarkTest01601 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01601");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01602.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01602.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed50a7ea96b2ab835631aa8c3bfc1ae9dcd72f1c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01602.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01602")
+public class BenchmarkTest01602 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01602");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01603.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01603.java
new file mode 100644
index 0000000000000000000000000000000000000000..9781e30b0d486859c4a34d0ee5a88a1f08260cfb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01603.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01603")
+public class BenchmarkTest01603 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01603");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a74856 = param; // assign
+            StringBuilder b74856 = new StringBuilder(a74856); // stick in stringbuilder
+            b74856.append(" SafeStuff"); // append some safe content
+            b74856.replace(
+                    b74856.length() - "Chars".length(),
+                    b74856.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map74856 = new java.util.HashMap<String, Object>();
+            map74856.put("key74856", b74856.toString()); // put in a collection
+            String c74856 = (String) map74856.get("key74856"); // get it back out
+            String d74856 = c74856.substring(0, c74856.length() - 1); // extract most of it
+            String e74856 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d74856.getBytes()))); // B64 encode and decode it
+            String f74856 = e74856.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g74856 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g74856); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01604.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01604.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa254068750659e08f065e2fcd8474e9645aee06
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01604.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01604")
+public class BenchmarkTest01604 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01604");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01605.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01605.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1d5c18a72164668efed8ceeb50ee6b5b9454b78
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01605.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01605")
+public class BenchmarkTest01605 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01605");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map97880 = new java.util.HashMap<String, Object>();
+            map97880.put("keyA-97880", "a_Value"); // put some stuff in the collection
+            map97880.put("keyB-97880", param); // put it in a collection
+            map97880.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map97880.get("keyB-97880"); // get it back out
+            bar = (String) map97880.get("keyA-97880"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01606.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01606.java
new file mode 100644
index 0000000000000000000000000000000000000000..96d9b672138f60cea117cbd6e6a9f1c6ada4d45a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01606.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01606")
+public class BenchmarkTest01606 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01606");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01607.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01607.java
new file mode 100644
index 0000000000000000000000000000000000000000..9044684f0bcf83ea34c84b182b47020f0b338012
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01607.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01607")
+public class BenchmarkTest01607 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01607");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01608.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01608.java
new file mode 100644
index 0000000000000000000000000000000000000000..fbcdbb4871964dcb1c4470229aa58940fe2c9230
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01608.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01608")
+public class BenchmarkTest01608 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01608");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map55872 = new java.util.HashMap<String, Object>();
+            map55872.put("keyA-55872", "a_Value"); // put some stuff in the collection
+            map55872.put("keyB-55872", param); // put it in a collection
+            map55872.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map55872.get("keyB-55872"); // get it back out
+            bar = (String) map55872.get("keyA-55872"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01609.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01609.java
new file mode 100644
index 0000000000000000000000000000000000000000..df465d6b2968958a99469e4a1f2cb16845491d8c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01609.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01609")
+public class BenchmarkTest01609 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01609");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01610.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01610.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b3636c775c9d476bf38a75cb821c35b77c57a9b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01610.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01610")
+public class BenchmarkTest01610 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01610");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01611.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01611.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5a37ffaef72e528ebe05da2bb269e20a6b4a2d8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01611.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01611")
+public class BenchmarkTest01611 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01611");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01612.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01612.java
new file mode 100644
index 0000000000000000000000000000000000000000..344ad660ec9a944d9c4105c78e66e21a53b9982f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01612.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01612")
+public class BenchmarkTest01612 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01612");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01613.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01613.java
new file mode 100644
index 0000000000000000000000000000000000000000..4baccc62848933a95420ed88cde8668f9d2a10f7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01613.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01613")
+public class BenchmarkTest01613 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01613");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01614.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01614.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c894e0ee76e995babbd4c75d5fe111dcdbfa145
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01614.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01614")
+public class BenchmarkTest01614 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01614");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01615.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01615.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd68489c7c5cdea4fc9e487a987d721f8066d099
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01615.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01615")
+public class BenchmarkTest01615 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01615");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz57216 = new StringBuilder(param);
+                bar =
+                        sbxyz57216
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01616.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01616.java
new file mode 100644
index 0000000000000000000000000000000000000000..d595f62865fbe0d7538b0c8a48b6d4fb38ca2aa1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01616.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01616")
+public class BenchmarkTest01616 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01616");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a53857 = param; // assign
+            StringBuilder b53857 = new StringBuilder(a53857); // stick in stringbuilder
+            b53857.append(" SafeStuff"); // append some safe content
+            b53857.replace(
+                    b53857.length() - "Chars".length(),
+                    b53857.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map53857 = new java.util.HashMap<String, Object>();
+            map53857.put("key53857", b53857.toString()); // put in a collection
+            String c53857 = (String) map53857.get("key53857"); // get it back out
+            String d53857 = c53857.substring(0, c53857.length() - 1); // extract most of it
+            String e53857 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d53857.getBytes()))); // B64 encode and decode it
+            String f53857 = e53857.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f53857); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01617.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01617.java
new file mode 100644
index 0000000000000000000000000000000000000000..54dff8b5a61f59f456377b43d88054ea85ade50e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01617.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01617")
+public class BenchmarkTest01617 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01617");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01618.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01618.java
new file mode 100644
index 0000000000000000000000000000000000000000..af67de12ca3360a7e9e83db174f0cdcff97b918b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01618.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-00/BenchmarkTest01618")
+public class BenchmarkTest01618 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01618");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01619.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01619.java
new file mode 100644
index 0000000000000000000000000000000000000000..772ea9037c4b9f3b7449f6307682e96e86444f48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01619.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01619")
+public class BenchmarkTest01619 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01619");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01620.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01620.java
new file mode 100644
index 0000000000000000000000000000000000000000..9eda789bdcd0369de14c9e502bb4702ab1f0ca5f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01620.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01620")
+public class BenchmarkTest01620 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01620");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01621.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01621.java
new file mode 100644
index 0000000000000000000000000000000000000000..080cfe8783e15da5e6adbf2065d11405f8644bbb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01621.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01621")
+public class BenchmarkTest01621 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01621");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01622.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01622.java
new file mode 100644
index 0000000000000000000000000000000000000000..390aaf0fa8bf3b70d4a40296c9a83a9e3f88d14c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01622.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01622")
+public class BenchmarkTest01622 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01622");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01623.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01623.java
new file mode 100644
index 0000000000000000000000000000000000000000..f20eb26339a294a236fb8b4b2c7b6aebd7c28606
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01623.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01623")
+public class BenchmarkTest01623 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01623");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01624.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01624.java
new file mode 100644
index 0000000000000000000000000000000000000000..51207158ca6a9d8547208f39066bde08acad7e8a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01624.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01624")
+public class BenchmarkTest01624 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01624");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01625.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01625.java
new file mode 100644
index 0000000000000000000000000000000000000000..4961e058670b1c9ad4ff2f5ef77b6a72a287aab9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01625.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01625")
+public class BenchmarkTest01625 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01625");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01626.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01626.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1d800daecfc3ced88cb4fbab7778e8d9b692e86
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01626.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01626")
+public class BenchmarkTest01626 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01626");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01627.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01627.java
new file mode 100644
index 0000000000000000000000000000000000000000..9936bbeb3dbbbff19bc059cab404e778aa4a0ab7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01627.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01627")
+public class BenchmarkTest01627 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01627");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01628.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01628.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d2137bff133f5e7712535a1f7638fc7ed223c8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01628.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01628")
+public class BenchmarkTest01628 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01628");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01629.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01629.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ec28e3ba95f6ecfb6cea10df4197e4cd9d73bc6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01629.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01629")
+public class BenchmarkTest01629 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01629");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01630.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01630.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7b9776ddd850f310a3ad492d45b840ccae6efde
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01630.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01630")
+public class BenchmarkTest01630 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01630");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01631.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01631.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c1c29f35e08fbad7c3ba88b8282d5a1b0c5a469
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01631.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01631")
+public class BenchmarkTest01631 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01631");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01632.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01632.java
new file mode 100644
index 0000000000000000000000000000000000000000..a169e8f928b0c0d846544453f93869ffaefb9d13
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01632.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01632")
+public class BenchmarkTest01632 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01632");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01633.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01633.java
new file mode 100644
index 0000000000000000000000000000000000000000..3559bfe46bd902d3283db8050399110026a754cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01633.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01633")
+public class BenchmarkTest01633 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest01633");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a31144 = param; // assign
+            StringBuilder b31144 = new StringBuilder(a31144); // stick in stringbuilder
+            b31144.append(" SafeStuff"); // append some safe content
+            b31144.replace(
+                    b31144.length() - "Chars".length(),
+                    b31144.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map31144 = new java.util.HashMap<String, Object>();
+            map31144.put("key31144", b31144.toString()); // put in a collection
+            String c31144 = (String) map31144.get("key31144"); // get it back out
+            String d31144 = c31144.substring(0, c31144.length() - 1); // extract most of it
+            String e31144 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d31144.getBytes()))); // B64 encode and decode it
+            String f31144 = e31144.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g31144 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g31144); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01634.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01634.java
new file mode 100644
index 0000000000000000000000000000000000000000..66dabf3a04fe1386f914e4fcd20e5ef1a4755a91
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01634.java	
@@ -0,0 +1,186 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01634")
+public class BenchmarkTest01634 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01634" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01634"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01634" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a37769 = param; // assign
+            StringBuilder b37769 = new StringBuilder(a37769); // stick in stringbuilder
+            b37769.append(" SafeStuff"); // append some safe content
+            b37769.replace(
+                    b37769.length() - "Chars".length(),
+                    b37769.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map37769 = new java.util.HashMap<String, Object>();
+            map37769.put("key37769", b37769.toString()); // put in a collection
+            String c37769 = (String) map37769.get("key37769"); // get it back out
+            String d37769 = c37769.substring(0, c37769.length() - 1); // extract most of it
+            String e37769 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d37769.getBytes()))); // B64 encode and decode it
+            String f37769 = e37769.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g37769 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g37769); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01635.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01635.java
new file mode 100644
index 0000000000000000000000000000000000000000..8330a34b7efa4ea53be2e8e976638d518a2ea8b3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01635.java	
@@ -0,0 +1,168 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01635")
+public class BenchmarkTest01635 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01635" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01635"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01635" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01636.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01636.java
new file mode 100644
index 0000000000000000000000000000000000000000..aaa6680fead95391e9f34631faa4a546c961851b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01636.java	
@@ -0,0 +1,167 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01636")
+public class BenchmarkTest01636 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01636" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01636"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01636" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01637.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01637.java
new file mode 100644
index 0000000000000000000000000000000000000000..f91cf76513c0e9b462e83f39778649facc0aa5d5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01637.java	
@@ -0,0 +1,188 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01637")
+public class BenchmarkTest01637 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01637" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01637"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01637" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01638.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01638.java
new file mode 100644
index 0000000000000000000000000000000000000000..706eddbebc0cc4573ba7a8826f16b3f455fd4c21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01638.java	
@@ -0,0 +1,155 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01638")
+public class BenchmarkTest01638 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01638" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01638"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01638" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a61263 = param; // assign
+            StringBuilder b61263 = new StringBuilder(a61263); // stick in stringbuilder
+            b61263.append(" SafeStuff"); // append some safe content
+            b61263.replace(
+                    b61263.length() - "Chars".length(),
+                    b61263.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map61263 = new java.util.HashMap<String, Object>();
+            map61263.put("key61263", b61263.toString()); // put in a collection
+            String c61263 = (String) map61263.get("key61263"); // get it back out
+            String d61263 = c61263.substring(0, c61263.length() - 1); // extract most of it
+            String e61263 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d61263.getBytes()))); // B64 encode and decode it
+            String f61263 = e61263.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f61263); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01639.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01639.java
new file mode 100644
index 0000000000000000000000000000000000000000..9fb5b5033f1ea1acb6dba454ff2b7255c14b0493
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01639.java	
@@ -0,0 +1,141 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01639")
+public class BenchmarkTest01639 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01639" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01639"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01639" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map62111 = new java.util.HashMap<String, Object>();
+            map62111.put("keyA-62111", "a_Value"); // put some stuff in the collection
+            map62111.put("keyB-62111", param); // put it in a collection
+            map62111.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map62111.get("keyB-62111"); // get it back out
+            bar = (String) map62111.get("keyA-62111"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01640.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01640.java
new file mode 100644
index 0000000000000000000000000000000000000000..5116098837f15e32fcbecfc35b308efd3a8eb6a8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01640.java	
@@ -0,0 +1,146 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01640")
+public class BenchmarkTest01640 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01640" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01640"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01640" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01641.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01641.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1c69d482d0fe756b495611f02268c2bac7ed7fb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01641.java	
@@ -0,0 +1,132 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01641")
+public class BenchmarkTest01641 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01641" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01641"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01641" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map5640 = new java.util.HashMap<String, Object>();
+            map5640.put("keyA-5640", "a_Value"); // put some stuff in the collection
+            map5640.put("keyB-5640", param); // put it in a collection
+            map5640.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map5640.get("keyB-5640"); // get it back out
+            bar = (String) map5640.get("keyA-5640"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01642.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01642.java
new file mode 100644
index 0000000000000000000000000000000000000000..a67573eeb6f9f4fe450ba30a307daed522524944
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01642.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01642")
+public class BenchmarkTest01642 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01642" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01642"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01642" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01643.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01643.java
new file mode 100644
index 0000000000000000000000000000000000000000..2648a0952677beec1829ff803a3e9ed0f220d313
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01643.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01643")
+public class BenchmarkTest01643 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01643" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01643"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01643" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01644.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01644.java
new file mode 100644
index 0000000000000000000000000000000000000000..13c80bceacf5b3ff9f4a7946309fb524ec662023
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01644.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01644")
+public class BenchmarkTest01644 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01644" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01644"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01644" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01645.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01645.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee2d1c26d2d31a2be9c2e5f336afe2956279c9a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01645.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01645")
+public class BenchmarkTest01645 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01645" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01645"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01645" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01646.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01646.java
new file mode 100644
index 0000000000000000000000000000000000000000..9931ecf774533cfd5c7228d6ab731d6c7735c5cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01646.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-01/BenchmarkTest01646")
+public class BenchmarkTest01646 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01646" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01646"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01646" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map84260 = new java.util.HashMap<String, Object>();
+            map84260.put("keyA-84260", "a_Value"); // put some stuff in the collection
+            map84260.put("keyB-84260", param); // put it in a collection
+            map84260.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map84260.get("keyB-84260"); // get it back out
+            bar = (String) map84260.get("keyA-84260"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01647.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01647.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ee093ca558ae7cadae52f1407cb3a82f83fb7de
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01647.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01647")
+public class BenchmarkTest01647 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01647" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01647"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01647" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01648.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01648.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce43a67b5bb2baf99ac9027a21c2f5a73a9df736
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01648.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01648")
+public class BenchmarkTest01648 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01648" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01648"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01648" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01649.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01649.java
new file mode 100644
index 0000000000000000000000000000000000000000..104baf9ac96a661028aa7194a12dbe488247565d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01649.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01649")
+public class BenchmarkTest01649 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01649" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01649"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01649" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map61654 = new java.util.HashMap<String, Object>();
+            map61654.put("keyA-61654", "a_Value"); // put some stuff in the collection
+            map61654.put("keyB-61654", param); // put it in a collection
+            map61654.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map61654.get("keyB-61654"); // get it back out
+            bar = (String) map61654.get("keyA-61654"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01650.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01650.java
new file mode 100644
index 0000000000000000000000000000000000000000..d207d981cd51b6666f2c4982051f7806ea5407bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01650.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01650")
+public class BenchmarkTest01650 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01650" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01650"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01650" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01651.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01651.java
new file mode 100644
index 0000000000000000000000000000000000000000..199bd787e32fa339209d4509ec698aca114afb2f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01651.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01651")
+public class BenchmarkTest01651 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01651" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01651"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01651" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01652.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01652.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3da5a27f8ba45f9388f847725a2ffb76582fe5f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01652.java	
@@ -0,0 +1,126 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01652")
+public class BenchmarkTest01652 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01652" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01652"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01652" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map16429 = new java.util.HashMap<String, Object>();
+            map16429.put("keyA-16429", "a_Value"); // put some stuff in the collection
+            map16429.put("keyB-16429", param); // put it in a collection
+            map16429.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map16429.get("keyB-16429"); // get it back out
+            bar = (String) map16429.get("keyA-16429"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01653.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01653.java
new file mode 100644
index 0000000000000000000000000000000000000000..81eaff3600a2893d12fdf6e24683a38830faeadf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01653.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01653")
+public class BenchmarkTest01653 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01653" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01653"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01653" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01654.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01654.java
new file mode 100644
index 0000000000000000000000000000000000000000..7cb8eea20515ef7f69ec16fab0be8a7ebebf8dc2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01654.java	
@@ -0,0 +1,137 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01654")
+public class BenchmarkTest01654 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01654" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01654"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01654" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01655.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01655.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ba77170bf1c55ad1cbc8aadb15f7cd7a0887fe1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01655.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01655")
+public class BenchmarkTest01655 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01655" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01655"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01655" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01656.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01656.java
new file mode 100644
index 0000000000000000000000000000000000000000..088d83aae18d6eaf7e2c406ebb7e3baf380210b5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01656.java	
@@ -0,0 +1,137 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01656")
+public class BenchmarkTest01656 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01656" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01656"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01656" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01657.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01657.java
new file mode 100644
index 0000000000000000000000000000000000000000..226f817caeab7ec1a8bde06f781849df8ebf24de
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01657.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01657")
+public class BenchmarkTest01657 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01657" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01657"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01657" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01658.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01658.java
new file mode 100644
index 0000000000000000000000000000000000000000..4565a5fb6d7ded1fd4e664869746d96be434538d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01658.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01658")
+public class BenchmarkTest01658 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01658" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01658"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01658" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01659.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01659.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5b840716d9820bbbf0862d646edb28377c3e52c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01659.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01659")
+public class BenchmarkTest01659 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01659" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01659"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01659" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01660.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01660.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e6f4ce7d73190984278031b318f94ec11aa1807
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01660.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01660")
+public class BenchmarkTest01660 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01660" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01660"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01660" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01661.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01661.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8fcec1a36588af46c8aac46ea9ef74aec3fd416
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01661.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01661")
+public class BenchmarkTest01661 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01661" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01661"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01661" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01662.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01662.java
new file mode 100644
index 0000000000000000000000000000000000000000..0bb9dec98b2588aa7f909907c599490b0de7b33c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01662.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01662")
+public class BenchmarkTest01662 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01662" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01662"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01662" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01663.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01663.java
new file mode 100644
index 0000000000000000000000000000000000000000..d23d7029c93a9b23799bc62153b6387d631db0e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01663.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01663")
+public class BenchmarkTest01663 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01663" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01663"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01663" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map36601 = new java.util.HashMap<String, Object>();
+            map36601.put("keyA-36601", "a_Value"); // put some stuff in the collection
+            map36601.put("keyB-36601", param); // put it in a collection
+            map36601.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map36601.get("keyB-36601"); // get it back out
+            bar = (String) map36601.get("keyA-36601"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01664.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01664.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d02ca5970e0df17e851d9c996c8bb387c8a611d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01664.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01664")
+public class BenchmarkTest01664 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01664" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01664"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01664" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01665.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01665.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c0d1a3b3719dec960335d8bdd2d8ce0fe9325c6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01665.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01665")
+public class BenchmarkTest01665 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01665" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01665"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01665" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz55941 = new StringBuilder(param);
+            String bar = sbxyz55941.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01666.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01666.java
new file mode 100644
index 0000000000000000000000000000000000000000..b10b2f13e8a5718c1ff71457405907595e55a6fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01666.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01666")
+public class BenchmarkTest01666 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01666" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01666"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01666" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz41549 = new StringBuilder(param);
+                bar =
+                        sbxyz41549
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01667.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01667.java
new file mode 100644
index 0000000000000000000000000000000000000000..8cf7e7ea040d93d39c9baf0c3f11b5e5f9846edf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01667.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01667")
+public class BenchmarkTest01667 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01667" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01667"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01667" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map96771 = new java.util.HashMap<String, Object>();
+            map96771.put("keyA-96771", "a-Value"); // put some stuff in the collection
+            map96771.put("keyB-96771", param); // put it in a collection
+            map96771.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map96771.get("keyB-96771"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01668.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01668.java
new file mode 100644
index 0000000000000000000000000000000000000000..4eacf8df3119f14484c21b10c7490bc57d1ee3d8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01668.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01668")
+public class BenchmarkTest01668 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01668" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01668"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01668" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map56839 = new java.util.HashMap<String, Object>();
+            map56839.put("keyA-56839", "a_Value"); // put some stuff in the collection
+            map56839.put("keyB-56839", param); // put it in a collection
+            map56839.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map56839.get("keyB-56839"); // get it back out
+            bar = (String) map56839.get("keyA-56839"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01669.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01669.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1d32be298dd6d32b5faee6770d3bce9571c6c88
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01669.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01669")
+public class BenchmarkTest01669 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01669" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01669"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01669" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01670.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01670.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9697a501e4ac625822d50f89cef80d90ebfff1b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01670.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01670")
+public class BenchmarkTest01670 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01670" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01670"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01670" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01671.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01671.java
new file mode 100644
index 0000000000000000000000000000000000000000..41ab34a0cf33c1ffb1ba2046941b4a60ddf78ffe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01671.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01671")
+public class BenchmarkTest01671 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01671" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01671"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01671" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01672.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01672.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb921b8b4072e10b49152b5270af248c54eed9aa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01672.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01672")
+public class BenchmarkTest01672 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01672" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01672"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01672" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01673.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01673.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae0dcb998b15db0c627014864cefea2e28941510
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01673.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01673")
+public class BenchmarkTest01673 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01673" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01673"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01673" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01674.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01674.java
new file mode 100644
index 0000000000000000000000000000000000000000..0575dc194e3089d627eec1fcb4c6ccc10ee95d7c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01674.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01674")
+public class BenchmarkTest01674 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01674" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01674"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01674" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01675.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01675.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4ad27175c160df8a456aae47453ca48d1a5569e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01675.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01675")
+public class BenchmarkTest01675 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01675" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01675"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01675" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01676.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01676.java
new file mode 100644
index 0000000000000000000000000000000000000000..17882aa3263f06ec4713a4cbbabedba5a13f6b80
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01676.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01676")
+public class BenchmarkTest01676 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01676" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01676"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01676" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01677.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01677.java
new file mode 100644
index 0000000000000000000000000000000000000000..68a9d9138173a7a9aadab35240fe69f59b8867bd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01677.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01677")
+public class BenchmarkTest01677 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01677" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01677"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01677" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01678.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01678.java
new file mode 100644
index 0000000000000000000000000000000000000000..01471f9b5f24f3712a1a7ec4725ebfdfa2fe37f9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01678.java	
@@ -0,0 +1,134 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01678")
+public class BenchmarkTest01678 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01678" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01678"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01678" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a96171 = param; // assign
+            StringBuilder b96171 = new StringBuilder(a96171); // stick in stringbuilder
+            b96171.append(" SafeStuff"); // append some safe content
+            b96171.replace(
+                    b96171.length() - "Chars".length(),
+                    b96171.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map96171 = new java.util.HashMap<String, Object>();
+            map96171.put("key96171", b96171.toString()); // put in a collection
+            String c96171 = (String) map96171.get("key96171"); // get it back out
+            String d96171 = c96171.substring(0, c96171.length() - 1); // extract most of it
+            String e96171 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d96171.getBytes()))); // B64 encode and decode it
+            String f96171 = e96171.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f96171); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01679.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01679.java
new file mode 100644
index 0000000000000000000000000000000000000000..4dd6655cecd88ced94739e4c51f8ca2c8072ed6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01679.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01679")
+public class BenchmarkTest01679 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01679" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01679"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01679" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01680.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01680.java
new file mode 100644
index 0000000000000000000000000000000000000000..915e1028c0e21013eb74ecfd3bba18f22f1d0837
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01680.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01680")
+public class BenchmarkTest01680 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01680" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01680"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01680" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01681.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01681.java
new file mode 100644
index 0000000000000000000000000000000000000000..ca723996013097336be3f61802d1d7a248bcf650
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01681.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01681")
+public class BenchmarkTest01681 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01681" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01681"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01681" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map97890 = new java.util.HashMap<String, Object>();
+            map97890.put("keyA-97890", "a_Value"); // put some stuff in the collection
+            map97890.put("keyB-97890", param); // put it in a collection
+            map97890.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map97890.get("keyB-97890"); // get it back out
+            bar = (String) map97890.get("keyA-97890"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01682.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01682.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f9bcdbafc06826b4ce2bc0901fab14b7ddc2c1c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01682.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01682")
+public class BenchmarkTest01682 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01682" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01682"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01682" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01683.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01683.java
new file mode 100644
index 0000000000000000000000000000000000000000..1598aad1a1c5b02e6362b07dea3a7d79aabaf510
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01683.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01683")
+public class BenchmarkTest01683 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01683" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01683"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01683" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01684.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01684.java
new file mode 100644
index 0000000000000000000000000000000000000000..a910628a043488ca806c2547380d4ea88481e9ce
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01684.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01684")
+public class BenchmarkTest01684 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01684" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01684"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01684" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz77558 = new StringBuilder(param);
+            String bar = sbxyz77558.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01685.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01685.java
new file mode 100644
index 0000000000000000000000000000000000000000..31ab38a81ee872ef9cc7dd2d615aab3b44209088
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01685.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01685")
+public class BenchmarkTest01685 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01685" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01685"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01685" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01686.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01686.java
new file mode 100644
index 0000000000000000000000000000000000000000..887379bcd608a87b838225576dc58ac3f02069a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01686.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01686")
+public class BenchmarkTest01686 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01686" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01686"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01686" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01687.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01687.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7a1c0ca14ae4e3372d2f4a7bf04ff202a7ffa4c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01687.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01687")
+public class BenchmarkTest01687 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01687" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01687"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01687" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01688.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01688.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fe911602d46e37ed8d5686b8e379260d16dbd4d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01688.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01688")
+public class BenchmarkTest01688 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01688" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01688"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01688" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01689.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01689.java
new file mode 100644
index 0000000000000000000000000000000000000000..a0a9390410fd503666bddcbf54ba2ad8fc39e45a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01689.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01689")
+public class BenchmarkTest01689 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01689" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01689"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01689" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01690.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01690.java
new file mode 100644
index 0000000000000000000000000000000000000000..9cf0cac076a407f481ec645d0e6140947d32352b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01690.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01690")
+public class BenchmarkTest01690 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01690" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01690"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01690" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01691.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01691.java
new file mode 100644
index 0000000000000000000000000000000000000000..23794b61dbcd047045fbcc039d5d19f757eea32f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01691.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-01/BenchmarkTest01691")
+public class BenchmarkTest01691 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01691" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01691"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01691" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01692.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01692.java
new file mode 100644
index 0000000000000000000000000000000000000000..fda573182bac9273e8f6c99bacc5b3b914f73aeb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01692.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01692")
+public class BenchmarkTest01692 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01692" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01692"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01692" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a28453 = param; // assign
+            StringBuilder b28453 = new StringBuilder(a28453); // stick in stringbuilder
+            b28453.append(" SafeStuff"); // append some safe content
+            b28453.replace(
+                    b28453.length() - "Chars".length(),
+                    b28453.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map28453 = new java.util.HashMap<String, Object>();
+            map28453.put("key28453", b28453.toString()); // put in a collection
+            String c28453 = (String) map28453.get("key28453"); // get it back out
+            String d28453 = c28453.substring(0, c28453.length() - 1); // extract most of it
+            String e28453 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d28453.getBytes()))); // B64 encode and decode it
+            String f28453 = e28453.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g28453 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g28453); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01693.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01693.java
new file mode 100644
index 0000000000000000000000000000000000000000..885fff6feb05ccfeb321e8a36a31788e74d34ea3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01693.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01693")
+public class BenchmarkTest01693 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01693" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01693"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01693" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01694.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01694.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6c564340c1f8167ba5ccfd485f2d3258b82d276
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01694.java	
@@ -0,0 +1,128 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01694")
+public class BenchmarkTest01694 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01694" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01694"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01694" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01695.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01695.java
new file mode 100644
index 0000000000000000000000000000000000000000..e40d4aef54d30ec1f6b7164047aac2068e166e5f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01695.java	
@@ -0,0 +1,136 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01695")
+public class BenchmarkTest01695 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01695" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01695"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01695" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01696.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01696.java
new file mode 100644
index 0000000000000000000000000000000000000000..58d96f710f6e70fb1c0d89d18b9019945c713ec0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01696.java	
@@ -0,0 +1,127 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01696")
+public class BenchmarkTest01696 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01696" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01696"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01696" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map83181 = new java.util.HashMap<String, Object>();
+            map83181.put("keyA-83181", "a-Value"); // put some stuff in the collection
+            map83181.put("keyB-83181", param); // put it in a collection
+            map83181.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map83181.get("keyB-83181"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01697.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01697.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d0d59642e130c441205e7f042c364153500861d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01697.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01697")
+public class BenchmarkTest01697 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01697" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01697"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01697" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz19197 = new StringBuilder(param);
+            String bar = sbxyz19197.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01698.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01698.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc3e6c6450155f1dc21a0defab07fb7f0597b93e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01698.java	
@@ -0,0 +1,148 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01698")
+public class BenchmarkTest01698 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01698" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01698"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01698" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a72232 = param; // assign
+            StringBuilder b72232 = new StringBuilder(a72232); // stick in stringbuilder
+            b72232.append(" SafeStuff"); // append some safe content
+            b72232.replace(
+                    b72232.length() - "Chars".length(),
+                    b72232.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map72232 = new java.util.HashMap<String, Object>();
+            map72232.put("key72232", b72232.toString()); // put in a collection
+            String c72232 = (String) map72232.get("key72232"); // get it back out
+            String d72232 = c72232.substring(0, c72232.length() - 1); // extract most of it
+            String e72232 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d72232.getBytes()))); // B64 encode and decode it
+            String f72232 = e72232.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g72232 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g72232); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01699.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01699.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fe51b153e8d146e04548d8fcb38b5132f768e82
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01699.java	
@@ -0,0 +1,127 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01699")
+public class BenchmarkTest01699 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01699" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01699"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01699" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01700.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01700.java
new file mode 100644
index 0000000000000000000000000000000000000000..db45c96d08a746b5ac901ee7a1fdd9751c61508e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01700.java	
@@ -0,0 +1,146 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01700")
+public class BenchmarkTest01700 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01700" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01700"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01700" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01701.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01701.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d95d1a6c5738dd0d7fbffb0c790559cc51bca0f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01701.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01701")
+public class BenchmarkTest01701 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01701" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01701"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01701" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01702.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01702.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7bd51e82608129c8e491239939d4c88248bbaef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01702.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01702")
+public class BenchmarkTest01702 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01702" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01702"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01702" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01703.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01703.java
new file mode 100644
index 0000000000000000000000000000000000000000..67f0a29ed27aa748a45afcab22bf70266d5b4abe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01703.java	
@@ -0,0 +1,127 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01703")
+public class BenchmarkTest01703 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01703" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01703"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01703" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01704.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01704.java
new file mode 100644
index 0000000000000000000000000000000000000000..aaf08f58a0356d8c4aa1570c5043ecc9192a8b73
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01704.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01704")
+public class BenchmarkTest01704 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01704" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01704"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01704" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01705.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01705.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff4dce20c16ff1d225963c5dd8ed0746d22571fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01705.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01705")
+public class BenchmarkTest01705 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01705" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01705"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01705" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01706.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01706.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f4c7ad42c45d23560863b6170b7897608c42278
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01706.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01706")
+public class BenchmarkTest01706 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01706" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01706"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01706" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01707.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01707.java
new file mode 100644
index 0000000000000000000000000000000000000000..513b24444755d81dec3caa84f93ec935c96f3907
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01707.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01707")
+public class BenchmarkTest01707 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01707" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01707"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01707" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map13101 = new java.util.HashMap<String, Object>();
+            map13101.put("keyA-13101", "a-Value"); // put some stuff in the collection
+            map13101.put("keyB-13101", param); // put it in a collection
+            map13101.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map13101.get("keyB-13101"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01708.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01708.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f4792aafac64cf3f615c6f831f97f131eb7f506
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01708.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01708")
+public class BenchmarkTest01708 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01708" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01708"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01708" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01709.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01709.java
new file mode 100644
index 0000000000000000000000000000000000000000..8bd828cc119ccd59c54863ef0f5a9f25361658a1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01709.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01709")
+public class BenchmarkTest01709 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01709" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01709"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01709" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a15574 = param; // assign
+            StringBuilder b15574 = new StringBuilder(a15574); // stick in stringbuilder
+            b15574.append(" SafeStuff"); // append some safe content
+            b15574.replace(
+                    b15574.length() - "Chars".length(),
+                    b15574.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map15574 = new java.util.HashMap<String, Object>();
+            map15574.put("key15574", b15574.toString()); // put in a collection
+            String c15574 = (String) map15574.get("key15574"); // get it back out
+            String d15574 = c15574.substring(0, c15574.length() - 1); // extract most of it
+            String e15574 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d15574.getBytes()))); // B64 encode and decode it
+            String f15574 = e15574.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f15574); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01710.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01710.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa33aeb1ca3b8183a80753e48f3d23c7a40b9645
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01710.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01710")
+public class BenchmarkTest01710 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01710" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01710"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01710" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01711.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01711.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c65571b4b917d40fb3b9e56f7d8e2dd22fdeeba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01711.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01711")
+public class BenchmarkTest01711 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01711" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01711"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01711" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01712.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01712.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e244cfe84bb2fd092e2a1cccb975d611aa9491a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01712.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01712")
+public class BenchmarkTest01712 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01712" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01712"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01712" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map6261 = new java.util.HashMap<String, Object>();
+            map6261.put("keyA-6261", "a-Value"); // put some stuff in the collection
+            map6261.put("keyB-6261", param); // put it in a collection
+            map6261.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map6261.get("keyB-6261"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01713.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01713.java
new file mode 100644
index 0000000000000000000000000000000000000000..73e2b09b5764caf3cbf207a9229ac0e41e112848
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01713.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01713")
+public class BenchmarkTest01713 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01713" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01713"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01713" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map83939 = new java.util.HashMap<String, Object>();
+            map83939.put("keyA-83939", "a_Value"); // put some stuff in the collection
+            map83939.put("keyB-83939", param); // put it in a collection
+            map83939.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map83939.get("keyB-83939"); // get it back out
+            bar = (String) map83939.get("keyA-83939"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01714.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01714.java
new file mode 100644
index 0000000000000000000000000000000000000000..d2202019475219ce633dd6620aeb7bb1fd896a1b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01714.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01714")
+public class BenchmarkTest01714 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01714" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01714"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01714" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01715.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01715.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a30fca1a7d271a008815b039d18ce749bf70f81
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01715.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01715")
+public class BenchmarkTest01715 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01715" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01715"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01715" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01716.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01716.java
new file mode 100644
index 0000000000000000000000000000000000000000..843c58dbac931772fd97b352ecf22dbc228de242
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01716.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01716")
+public class BenchmarkTest01716 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01716" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01716"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01716" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01717.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01717.java
new file mode 100644
index 0000000000000000000000000000000000000000..3abda981fcc30e1e5caf7e986aac64d260c99f7c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01717.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01717")
+public class BenchmarkTest01717 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01717" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01717"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01717" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01718.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01718.java
new file mode 100644
index 0000000000000000000000000000000000000000..79d67b5ba163d2323b09e1681ecec1aea72f849e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01718.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01718")
+public class BenchmarkTest01718 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01718" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01718"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01718" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01719.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01719.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9d06856e8a7743fc61a8b7ff3a9303f5b6ec7a7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01719.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01719")
+public class BenchmarkTest01719 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01719" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01719"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01719" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01720.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01720.java
new file mode 100644
index 0000000000000000000000000000000000000000..19d4543177f3027d115593e0e0cf96759f8481f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01720.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01720")
+public class BenchmarkTest01720 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01720" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01720"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01720" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01721.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01721.java
new file mode 100644
index 0000000000000000000000000000000000000000..f31d1778cef9210c31651170a25d2b1ca27fd1cd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01721.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01721")
+public class BenchmarkTest01721 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01721" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01721"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01721" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01722.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01722.java
new file mode 100644
index 0000000000000000000000000000000000000000..faa9f3793dde61be3f3709e2f6445842933eab72
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01722.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01722")
+public class BenchmarkTest01722 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01722" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01722"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01722" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map33422 = new java.util.HashMap<String, Object>();
+            map33422.put("keyA-33422", "a_Value"); // put some stuff in the collection
+            map33422.put("keyB-33422", param); // put it in a collection
+            map33422.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map33422.get("keyB-33422"); // get it back out
+            bar = (String) map33422.get("keyA-33422"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01723.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01723.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e99c2e39bee3d340bc971ef75c82f9384126f15
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01723.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01723")
+public class BenchmarkTest01723 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01723" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01723"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01723" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01724.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01724.java
new file mode 100644
index 0000000000000000000000000000000000000000..913c5c0173f3eaeb893143200b6a985dd53aae53
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01724.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01724")
+public class BenchmarkTest01724 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01724" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01724"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01724" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01725.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01725.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c90d7253696dd48d4b7505958d6d73bab630d78
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01725.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01725")
+public class BenchmarkTest01725 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01725" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01725"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01725" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01726.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01726.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa792974d2fff9f6b996503fc9cfab308f2142ec
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01726.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01726")
+public class BenchmarkTest01726 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01726" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01726"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01726" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01727.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01727.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b93ac16947270b3fa23e35061fab045526107eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01727.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01727")
+public class BenchmarkTest01727 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01727" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01727"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01727" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01728.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01728.java
new file mode 100644
index 0000000000000000000000000000000000000000..488c72184ad56698d1840d22f81514ddd510a3c0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01728.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01728")
+public class BenchmarkTest01728 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01728" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01728"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01728" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01729.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01729.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3f9c01d32fba98ba16cb8ccc9585bbb7ff2e14a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01729.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01729")
+public class BenchmarkTest01729 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01729" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01729"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01729" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01730.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01730.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3348b6bb8a57e3a3bbdc3f2f19d3e89d14e58f8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01730.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01730")
+public class BenchmarkTest01730 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01730" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01730"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01730" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01731.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01731.java
new file mode 100644
index 0000000000000000000000000000000000000000..bac7b488b532ef0f902d28c04b37fb85a630ed6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01731.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01731")
+public class BenchmarkTest01731 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01731" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01731"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01731" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01732.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01732.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b541ec65460a79c6d6640b77b441cf63f201326
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01732.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01732")
+public class BenchmarkTest01732 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01732" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01732"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01732" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01733.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01733.java
new file mode 100644
index 0000000000000000000000000000000000000000..5640ce4191b81578e4c436c062f1201461eec4d7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01733.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01733")
+public class BenchmarkTest01733 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01733" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01733"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01733" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01734.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01734.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a6ca5b399d9a53b0a70bb00a6637a6b37bb8d9e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01734.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01734")
+public class BenchmarkTest01734 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01734" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01734"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01734" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01735.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01735.java
new file mode 100644
index 0000000000000000000000000000000000000000..21e00421dec71950794da5fd1088ed964411f669
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01735.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01735")
+public class BenchmarkTest01735 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01735" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01735"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01735" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01736.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01736.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d0838a12acb119b75340db07a24f65ab710c2f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01736.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01736")
+public class BenchmarkTest01736 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest01736" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest01736"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest01736" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01737.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01737.java
new file mode 100644
index 0000000000000000000000000000000000000000..1da12cddc23e25a3a79679bd331ccf01124bd9f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01737.java	
@@ -0,0 +1,143 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01737")
+public class BenchmarkTest01737 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01737");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01738.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01738.java
new file mode 100644
index 0000000000000000000000000000000000000000..a006575e6ace1d44ad03a83a0e9266031142ce21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01738.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01738")
+public class BenchmarkTest01738 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01738");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01739.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01739.java
new file mode 100644
index 0000000000000000000000000000000000000000..547bcbad28a55e635c1246c70487040ab790e9c6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01739.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01739")
+public class BenchmarkTest01739 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01739");
+
+        String bar = new Test().doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz60534 = new StringBuilder(param);
+            String bar = sbxyz60534.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01740.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01740.java
new file mode 100644
index 0000000000000000000000000000000000000000..568787cf0fa539fbc82dc1bff1c9905ecd84996b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01740.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01740")
+public class BenchmarkTest01740 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01740");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01741.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01741.java
new file mode 100644
index 0000000000000000000000000000000000000000..954a27ef9306e82439d69d713c270f2a0d9a603d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01741.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01741")
+public class BenchmarkTest01741 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01741");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                StringBuilder sbxyz82048 = new StringBuilder(param);
+                bar =
+                        sbxyz82048
+                                .replace(param.length() - "Z".length(), param.length(), "Z")
+                                .toString();
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01742.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01742.java
new file mode 100644
index 0000000000000000000000000000000000000000..89431a236c0385d4afe323cc8f6d98d57d514eeb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01742.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01742")
+public class BenchmarkTest01742 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01742");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01743.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01743.java
new file mode 100644
index 0000000000000000000000000000000000000000..70e8b0328dc11a09ffbc43328ef8a19bd2aa6c20
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01743.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01743")
+public class BenchmarkTest01743 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01743");
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01744.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01744.java
new file mode 100644
index 0000000000000000000000000000000000000000..bab922af29e312412135a410e1283019d267ad6d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01744.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01744")
+public class BenchmarkTest01744 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01744");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a17402 = param; // assign
+            StringBuilder b17402 = new StringBuilder(a17402); // stick in stringbuilder
+            b17402.append(" SafeStuff"); // append some safe content
+            b17402.replace(
+                    b17402.length() - "Chars".length(),
+                    b17402.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map17402 = new java.util.HashMap<String, Object>();
+            map17402.put("key17402", b17402.toString()); // put in a collection
+            String c17402 = (String) map17402.get("key17402"); // get it back out
+            String d17402 = c17402.substring(0, c17402.length() - 1); // extract most of it
+            String e17402 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d17402.getBytes()))); // B64 encode and decode it
+            String f17402 = e17402.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g17402 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g17402); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01745.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01745.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee56d8c29788bd6db078ae6a5602f2f79b57a27f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01745.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01745")
+public class BenchmarkTest01745 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01745");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01746.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01746.java
new file mode 100644
index 0000000000000000000000000000000000000000..c44ed50e2fb53f54363f7a44dd1464b5d09c246c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01746.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01746")
+public class BenchmarkTest01746 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01746");
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01747.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01747.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc4d73b3c99f17bacf8c3386af83ff58614d6fad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01747.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01747")
+public class BenchmarkTest01747 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01747");
+
+        String bar = new Test().doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01748.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01748.java
new file mode 100644
index 0000000000000000000000000000000000000000..e565a6f59ade141faad2c1ac25b7d44264c6e583
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01748.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01748")
+public class BenchmarkTest01748 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01748");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01749.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01749.java
new file mode 100644
index 0000000000000000000000000000000000000000..297cc9ac1710cace7b109a857133e7b150171621
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01749.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01749")
+public class BenchmarkTest01749 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01749");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01750.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01750.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb1670cfe672110a7ce38835aea34497b8992344
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01750.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01750")
+public class BenchmarkTest01750 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01750");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01751.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01751.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e3863f1e43e07f6429483095e4067d12bbbf873
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01751.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01751")
+public class BenchmarkTest01751 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01751");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01752.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01752.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f92dacc393b3b38183ea099fe5e40c8b386ac90
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01752.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01752")
+public class BenchmarkTest01752 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01752");
+
+        String bar = new Test().doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map11351 = new java.util.HashMap<String, Object>();
+            map11351.put("keyA-11351", "a-Value"); // put some stuff in the collection
+            map11351.put("keyB-11351", param); // put it in a collection
+            map11351.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map11351.get("keyB-11351"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01753.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01753.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4d03b281cd4f6413e654066ff6d376af6d85083
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01753.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01753")
+public class BenchmarkTest01753 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01753");
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01754.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01754.java
new file mode 100644
index 0000000000000000000000000000000000000000..dedbb63ecdce6431b59288cd88059d8f4d63b384
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01754.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01754")
+public class BenchmarkTest01754 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01754");
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map91865 = new java.util.HashMap<String, Object>();
+            map91865.put("keyA-91865", "a-Value"); // put some stuff in the collection
+            map91865.put("keyB-91865", param); // put it in a collection
+            map91865.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map91865.get("keyB-91865"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01755.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01755.java
new file mode 100644
index 0000000000000000000000000000000000000000..06e98e3088be0850daeca39f2b6466a4b7220b25
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01755.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01755")
+public class BenchmarkTest01755 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01755");
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map69635 = new java.util.HashMap<String, Object>();
+            map69635.put("keyA-69635", "a-Value"); // put some stuff in the collection
+            map69635.put("keyB-69635", param); // put it in a collection
+            map69635.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map69635.get("keyB-69635"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01756.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01756.java
new file mode 100644
index 0000000000000000000000000000000000000000..04614c34b07998f3091fb7e10ddaab8f196a3b47
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01756.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01756")
+public class BenchmarkTest01756 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01756");
+
+        String bar = new Test().doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01757.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01757.java
new file mode 100644
index 0000000000000000000000000000000000000000..af3d5dc00f6560f58dee73f1dc0d11ee495e96b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01757.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01757")
+public class BenchmarkTest01757 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01757");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                bar =
+                        new String(
+                                org.apache.commons.codec.binary.Base64.decodeBase64(
+                                        org.apache.commons.codec.binary.Base64.encodeBase64(
+                                                param.getBytes())));
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01758.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01758.java
new file mode 100644
index 0000000000000000000000000000000000000000..a0fdec59a9a0264170c6f27bce655db33ebce873
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01758.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01758")
+public class BenchmarkTest01758 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01758");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01759.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01759.java
new file mode 100644
index 0000000000000000000000000000000000000000..789909439980ccbf9c953549c89577013030cf3c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01759.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-01/BenchmarkTest01759")
+public class BenchmarkTest01759 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01759");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01760.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01760.java
new file mode 100644
index 0000000000000000000000000000000000000000..daf6083e6ca14ae169d731719d48d29e7424fe3c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01760.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01760")
+public class BenchmarkTest01760 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01760");
+
+        String bar = new Test().doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01761.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01761.java
new file mode 100644
index 0000000000000000000000000000000000000000..a37bd530dcf97ab6a91bf4114f832415832e92fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01761.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01761")
+public class BenchmarkTest01761 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01761");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01762.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01762.java
new file mode 100644
index 0000000000000000000000000000000000000000..baddcafe3bcc3d79535c0c6141960851c177e349
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01762.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01762")
+public class BenchmarkTest01762 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01762");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01763.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01763.java
new file mode 100644
index 0000000000000000000000000000000000000000..f05bb1f99010264d9131140dadb2906924ecb823
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01763.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01763")
+public class BenchmarkTest01763 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01763");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01764.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01764.java
new file mode 100644
index 0000000000000000000000000000000000000000..7df22c42b8c01d57e73e15a7bb734383ecfa6ebf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01764.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01764")
+public class BenchmarkTest01764 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01764");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01765.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01765.java
new file mode 100644
index 0000000000000000000000000000000000000000..275d46125f42c7799a630b87841c6fcfd5690b69
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01765.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01765")
+public class BenchmarkTest01765 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01765");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01766.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01766.java
new file mode 100644
index 0000000000000000000000000000000000000000..527b603c64ec8453a38cdc8e64fb9fe03e5799b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01766.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01766")
+public class BenchmarkTest01766 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01766");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+            if (param != null && param.length() > 1) {
+                bar = param.substring(0, param.length() - 1);
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01767.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01767.java
new file mode 100644
index 0000000000000000000000000000000000000000..4617ae08bad89c663d4c3716d8c868b6bfd82e88
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01767.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01767")
+public class BenchmarkTest01767 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01767");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01768.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01768.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a253b675f6a0ce7aa7924ac263cbc11d8e314a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01768.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01768")
+public class BenchmarkTest01768 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01768");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01769.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01769.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b533fe989b7555fd1663cdb39beb4c63d2da1d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01769.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01769")
+public class BenchmarkTest01769 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01769");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01770.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01770.java
new file mode 100644
index 0000000000000000000000000000000000000000..722e076f9a7275d17c2073fb9963146bddb2c5f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01770.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01770")
+public class BenchmarkTest01770 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01770");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz41282 = new StringBuilder(param);
+            String bar = sbxyz41282.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01771.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01771.java
new file mode 100644
index 0000000000000000000000000000000000000000..043dee0ee23af1a82576b054255f102f9bfe5ff5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01771.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01771")
+public class BenchmarkTest01771 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01771");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a58724 = param; // assign
+            StringBuilder b58724 = new StringBuilder(a58724); // stick in stringbuilder
+            b58724.append(" SafeStuff"); // append some safe content
+            b58724.replace(
+                    b58724.length() - "Chars".length(),
+                    b58724.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map58724 = new java.util.HashMap<String, Object>();
+            map58724.put("key58724", b58724.toString()); // put in a collection
+            String c58724 = (String) map58724.get("key58724"); // get it back out
+            String d58724 = c58724.substring(0, c58724.length() - 1); // extract most of it
+            String e58724 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d58724.getBytes()))); // B64 encode and decode it
+            String f58724 = e58724.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f58724); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01772.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01772.java
new file mode 100644
index 0000000000000000000000000000000000000000..c63dbf611fc07d92d977a5dc214de98354f104cd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01772.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01772")
+public class BenchmarkTest01772 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01772");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            StringBuilder sbxyz76680 = new StringBuilder(param);
+            String bar = sbxyz76680.append("_SafeStuff").toString();
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01773.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01773.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6d919765074baa67069527c022795111e964a68
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01773.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01773")
+public class BenchmarkTest01773 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01773");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01774.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01774.java
new file mode 100644
index 0000000000000000000000000000000000000000..401e95f313f986ed95ce9cbf63029bf102ead759
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01774.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01774")
+public class BenchmarkTest01774 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01774");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map58318 = new java.util.HashMap<String, Object>();
+            map58318.put("keyA-58318", "a_Value"); // put some stuff in the collection
+            map58318.put("keyB-58318", param); // put it in a collection
+            map58318.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map58318.get("keyB-58318"); // get it back out
+            bar = (String) map58318.get("keyA-58318"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01775.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01775.java
new file mode 100644
index 0000000000000000000000000000000000000000..d899b6327e321cc982cfdd1d9c1ce8fc7bed5a4d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01775.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01775")
+public class BenchmarkTest01775 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01775");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01776.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01776.java
new file mode 100644
index 0000000000000000000000000000000000000000..5df7291a24054cefadb2b174af8e7d4af2e71125
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01776.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01776")
+public class BenchmarkTest01776 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01776");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map3531 = new java.util.HashMap<String, Object>();
+            map3531.put("keyA-3531", "a_Value"); // put some stuff in the collection
+            map3531.put("keyB-3531", param); // put it in a collection
+            map3531.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map3531.get("keyB-3531"); // get it back out
+            bar = (String) map3531.get("keyA-3531"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01777.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01777.java
new file mode 100644
index 0000000000000000000000000000000000000000..74273857e8d48cf18cd060e5bef599a4888596ec
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01777.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01777")
+public class BenchmarkTest01777 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01777");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01778.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01778.java
new file mode 100644
index 0000000000000000000000000000000000000000..613c8e6e0f1ab41f4875f3774aee3861397a1469
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01778.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01778")
+public class BenchmarkTest01778 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01778");
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01779.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01779.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb7c981be6c531406de151eaa186d686407c4676
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01779.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01779")
+public class BenchmarkTest01779 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01779");
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01780.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01780.java
new file mode 100644
index 0000000000000000000000000000000000000000..fae980b305b244e52b3f4be4ec3d08dc8d3d86bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01780.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01780")
+public class BenchmarkTest01780 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01780");
+
+        String bar = new Test().doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map90655 = new java.util.HashMap<String, Object>();
+            map90655.put("keyA-90655", "a_Value"); // put some stuff in the collection
+            map90655.put("keyB-90655", param); // put it in a collection
+            map90655.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map90655.get("keyB-90655"); // get it back out
+            bar = (String) map90655.get("keyA-90655"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01781.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01781.java
new file mode 100644
index 0000000000000000000000000000000000000000..c15b340585cb48bbf5b087c24a4e764004aff46d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01781.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01781")
+public class BenchmarkTest01781 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01781");
+
+        String bar = new Test().doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01782.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01782.java
new file mode 100644
index 0000000000000000000000000000000000000000..510c28f7f4326bbd74c2b556e473a713f566e3fd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01782.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01782")
+public class BenchmarkTest01782 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01782");
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01783.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01783.java
new file mode 100644
index 0000000000000000000000000000000000000000..9201a21a6849be5f6eef21848f4fb9dab56fb5c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01783.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01783")
+public class BenchmarkTest01783 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01783");
+
+        String bar = new Test().doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01784.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01784.java
new file mode 100644
index 0000000000000000000000000000000000000000..e633a7aaf039ff46fbac79b13f6b0d1df3c78c0d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01784.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01784")
+public class BenchmarkTest01784 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01784");
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01785.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01785.java
new file mode 100644
index 0000000000000000000000000000000000000000..16b3be54fd4962ed5e12c26c955c9affbc742931
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01785.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01785")
+public class BenchmarkTest01785 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01785");
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01786.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01786.java
new file mode 100644
index 0000000000000000000000000000000000000000..30e1c396aaf9a8c9aff9dd0ede1a4314e1e64be6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01786.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01786")
+public class BenchmarkTest01786 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01786");
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01787.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01787.java
new file mode 100644
index 0000000000000000000000000000000000000000..4135cb941dbfac3aaf565a96bb352efff352590e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01787.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-03/BenchmarkTest01787")
+public class BenchmarkTest01787 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01787");
+
+        String bar = new Test().doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01788.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01788.java
new file mode 100644
index 0000000000000000000000000000000000000000..2dc36b697c37dabae45bc8fe73c2be950367c91d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01788.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01788")
+public class BenchmarkTest01788 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01788");
+
+        String bar = new Test().doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01789.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01789.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ec604dbf28c78eab00ff9e2204db5f10412d1c1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01789.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01789")
+public class BenchmarkTest01789 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01789");
+
+        String bar = new Test().doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01790.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01790.java
new file mode 100644
index 0000000000000000000000000000000000000000..b1ecf02505f26c5ef6af7f3f2c2ff283c1fd00b2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01790.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01790")
+public class BenchmarkTest01790 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01790");
+
+        String bar = new Test().doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01791.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01791.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce43fa323ea957cab615aa75681f82d00b15e478
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01791.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01791")
+public class BenchmarkTest01791 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01791");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01792.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01792.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee397d5a93e16be6683729acbee9bb86eed0ce0f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01792.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01792")
+public class BenchmarkTest01792 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01792");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01793.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01793.java
new file mode 100644
index 0000000000000000000000000000000000000000..511db28ce26534d171e129466b69dba1f81d873b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01793.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01793")
+public class BenchmarkTest01793 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01793");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01794.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01794.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f5765bc2ab5fbc7fb33e6b14b0651ef83ef2bfe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01794.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01794")
+public class BenchmarkTest01794 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01794");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01795.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01795.java
new file mode 100644
index 0000000000000000000000000000000000000000..97dae8c1e96e3bf488662f0494c82ae388031620
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01795.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01795")
+public class BenchmarkTest01795 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01795");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(0); // get the param value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01796.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01796.java
new file mode 100644
index 0000000000000000000000000000000000000000..a0db4f09883601f2e52a7fff233c684698caefdf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01796.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01796")
+public class BenchmarkTest01796 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01796");
+
+        String bar = new Test().doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01797.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01797.java
new file mode 100644
index 0000000000000000000000000000000000000000..b0c1b781a872dd01e487df65b8d8b3894669c5e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01797.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01797")
+public class BenchmarkTest01797 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01797");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map85341 = new java.util.HashMap<String, Object>();
+            map85341.put("keyA-85341", "a_Value"); // put some stuff in the collection
+            map85341.put("keyB-85341", param); // put it in a collection
+            map85341.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map85341.get("keyB-85341"); // get it back out
+            bar = (String) map85341.get("keyA-85341"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01798.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01798.java
new file mode 100644
index 0000000000000000000000000000000000000000..462f5d52c9032ac22daa36b0607f950490ba6f0f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01798.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01798")
+public class BenchmarkTest01798 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01798");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "";
+            if (param != null) bar = param.split(" ")[0];
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01799.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01799.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4f38afb79ef9c5da1f9fd74d0ac51ddfa0db085
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01799.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01799")
+public class BenchmarkTest01799 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01799");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01800.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01800.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d98f130ba6b2670e4ac4ac0815d0da3ea8bc0fc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01800.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01800")
+public class BenchmarkTest01800 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01800");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a71684 = param; // assign
+            StringBuilder b71684 = new StringBuilder(a71684); // stick in stringbuilder
+            b71684.append(" SafeStuff"); // append some safe content
+            b71684.replace(
+                    b71684.length() - "Chars".length(),
+                    b71684.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map71684 = new java.util.HashMap<String, Object>();
+            map71684.put("key71684", b71684.toString()); // put in a collection
+            String c71684 = (String) map71684.get("key71684"); // get it back out
+            String d71684 = c71684.substring(0, c71684.length() - 1); // extract most of it
+            String e71684 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d71684.getBytes()))); // B64 encode and decode it
+            String f71684 = e71684.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String bar = thing.doSomething(f71684); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01801.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01801.java
new file mode 100644
index 0000000000000000000000000000000000000000..218cff2a02ffdc43abc26672ca9296eb5915965f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01801.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01801")
+public class BenchmarkTest01801 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01801");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01802.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01802.java
new file mode 100644
index 0000000000000000000000000000000000000000..904ad9bc73e0a7391badb0af2e404871c34948f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01802.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01802")
+public class BenchmarkTest01802 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01802");
+
+        String bar = new Test().doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01803.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01803.java
new file mode 100644
index 0000000000000000000000000000000000000000..9bc99cafc61200e0eb68f8c40fda0920d5f6fd64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01803.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01803")
+public class BenchmarkTest01803 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01803");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01804.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01804.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d7d7808299d36d22b27a0deed4116eed843c677
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01804.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01804")
+public class BenchmarkTest01804 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01804");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map31481 = new java.util.HashMap<String, Object>();
+            map31481.put("keyA-31481", "a_Value"); // put some stuff in the collection
+            map31481.put("keyB-31481", param); // put it in a collection
+            map31481.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map31481.get("keyB-31481"); // get it back out
+            bar = (String) map31481.get("keyA-31481"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01805.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01805.java
new file mode 100644
index 0000000000000000000000000000000000000000..cdbfb3938f1fefe0516f9202c243b9fdcd12a6c9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01805.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01805")
+public class BenchmarkTest01805 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01805");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map10271 = new java.util.HashMap<String, Object>();
+            map10271.put("keyA-10271", "a_Value"); // put some stuff in the collection
+            map10271.put("keyB-10271", param); // put it in a collection
+            map10271.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map10271.get("keyB-10271"); // get it back out
+            bar = (String) map10271.get("keyA-10271"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01806.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01806.java
new file mode 100644
index 0000000000000000000000000000000000000000..c24c85f55787c0a5294c38e56e4112d6647604af
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01806.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01806")
+public class BenchmarkTest01806 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01806");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01807.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01807.java
new file mode 100644
index 0000000000000000000000000000000000000000..ebcbc84960fce89fe72b5c49430486e9ccb41f84
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01807.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01807")
+public class BenchmarkTest01807 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01807");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01808.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01808.java
new file mode 100644
index 0000000000000000000000000000000000000000..553ad980142375a27713240d49bfeea0638e2f50
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01808.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01808")
+public class BenchmarkTest01808 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01808");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bob";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bob's your uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01809.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01809.java
new file mode 100644
index 0000000000000000000000000000000000000000..b3fd4ba1bc35c7d609502067b657b0c4ed35dc8f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01809.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01809")
+public class BenchmarkTest01809 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01809");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            // Chain a bunch of propagators in sequence
+            String a64594 = param; // assign
+            StringBuilder b64594 = new StringBuilder(a64594); // stick in stringbuilder
+            b64594.append(" SafeStuff"); // append some safe content
+            b64594.replace(
+                    b64594.length() - "Chars".length(),
+                    b64594.length(),
+                    "Chars"); // replace some of the end content
+            java.util.HashMap<String, Object> map64594 = new java.util.HashMap<String, Object>();
+            map64594.put("key64594", b64594.toString()); // put in a collection
+            String c64594 = (String) map64594.get("key64594"); // get it back out
+            String d64594 = c64594.substring(0, c64594.length() - 1); // extract most of it
+            String e64594 =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            d64594.getBytes()))); // B64 encode and decode it
+            String f64594 = e64594.split(" ")[0]; // split it on a space
+            org.owasp.benchmark.helpers.ThingInterface thing =
+                    org.owasp.benchmark.helpers.ThingFactory.createThing();
+            String g64594 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+            String bar = thing.doSomething(g64594); // reflection
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01810.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01810.java
new file mode 100644
index 0000000000000000000000000000000000000000..3814158d9613adbc6acade6ff0cf9b0801b8518f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01810.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01810")
+public class BenchmarkTest01810 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01810");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns param to bar on false condition
+            int num = 106;
+
+            bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01811.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01811.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8a5eb44670fda75f7ebeb8e86d849de0f47b520
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01811.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01811")
+public class BenchmarkTest01811 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01811");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map31047 = new java.util.HashMap<String, Object>();
+            map31047.put("keyA-31047", "a_Value"); // put some stuff in the collection
+            map31047.put("keyB-31047", param); // put it in a collection
+            map31047.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map31047.get("keyB-31047"); // get it back out
+            bar = (String) map31047.get("keyA-31047"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01812.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01812.java
new file mode 100644
index 0000000000000000000000000000000000000000..9356d944c6282c4652d942860e5d421584f53856
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01812.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01812")
+public class BenchmarkTest01812 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01812");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map20703 = new java.util.HashMap<String, Object>();
+            map20703.put("keyA-20703", "a_Value"); // put some stuff in the collection
+            map20703.put("keyB-20703", param); // put it in a collection
+            map20703.put("keyC", "another_Value"); // put some stuff in the collection
+            bar = (String) map20703.get("keyB-20703"); // get it back out
+            bar = (String) map20703.get("keyA-20703"); // get safe value back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01813.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01813.java
new file mode 100644
index 0000000000000000000000000000000000000000..b82620996f7b3476d84993ef7bec43a110c9622f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01813.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-03/BenchmarkTest01813")
+public class BenchmarkTest01813 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01813");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01814.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01814.java
new file mode 100644
index 0000000000000000000000000000000000000000..edd24956f862914934edc2b2287fba5c94cfdc38
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01814.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01814")
+public class BenchmarkTest01814 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01814");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+            String guess = "ABC";
+            char switchTarget = guess.charAt(2);
+
+            // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+            switch (switchTarget) {
+                case 'A':
+                    bar = param;
+                    break;
+                case 'B':
+                    bar = "bobs_your_uncle";
+                    break;
+                case 'C':
+                case 'D':
+                    bar = param;
+                    break;
+                default:
+                    bar = "bobs_your_uncle";
+                    break;
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01815.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01815.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0f1a15f847966b46ab5a156cc648f105a4d8252
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01815.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01815")
+public class BenchmarkTest01815 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01815");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map72704 = new java.util.HashMap<String, Object>();
+            map72704.put("keyA-72704", "a-Value"); // put some stuff in the collection
+            map72704.put("keyB-72704", param); // put it in a collection
+            map72704.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map72704.get("keyB-72704"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01816.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01816.java
new file mode 100644
index 0000000000000000000000000000000000000000..c407ba36e54b37650539d72137bbaa246d9f76fc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01816.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01816")
+public class BenchmarkTest01816 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01816");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple ? condition that assigns constant to bar on true condition
+            int num = 106;
+
+            bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01817.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01817.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d414d31f5e28f5b03865403c8188a433cf9808b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01817.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01817")
+public class BenchmarkTest01817 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01817");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns param to bar on true condition
+            int num = 196;
+            if ((500 / 42) + num > 200) bar = param;
+            else bar = "This should never happen";
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01818.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01818.java
new file mode 100644
index 0000000000000000000000000000000000000000..e08bde2b6ee6966c742fed8e6bd9094de4dac4c2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01818.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01818")
+public class BenchmarkTest01818 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01818");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01819.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01819.java
new file mode 100644
index 0000000000000000000000000000000000000000..164e2ced0780b30849d83b49ccbacaa211d615e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01819.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01819")
+public class BenchmarkTest01819 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01819");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "safe!";
+            java.util.HashMap<String, Object> map64759 = new java.util.HashMap<String, Object>();
+            map64759.put("keyA-64759", "a-Value"); // put some stuff in the collection
+            map64759.put("keyB-64759", param); // put it in a collection
+            map64759.put("keyC", "another-Value"); // put some stuff in the collection
+            bar = (String) map64759.get("keyB-64759"); // get it back out
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01820.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01820.java
new file mode 100644
index 0000000000000000000000000000000000000000..3adc0026442445343ca5aea7c3eb0fcb75fe00f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01820.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01820")
+public class BenchmarkTest01820 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01820");
+
+        String bar = new Test().doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar = "alsosafe";
+            if (param != null) {
+                java.util.List<String> valuesList = new java.util.ArrayList<String>();
+                valuesList.add("safe");
+                valuesList.add(param);
+                valuesList.add("moresafe");
+
+                valuesList.remove(0); // remove the 1st safe value
+
+                bar = valuesList.get(1); // get the last 'safe' value
+            }
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01821.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01821.java
new file mode 100644
index 0000000000000000000000000000000000000000..2474142b975352a491e365602e8e837492eeca26
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01821.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01821")
+public class BenchmarkTest01821 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest01821");
+
+        String bar = new Test().doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private class Test {
+
+        public String doSomething(HttpServletRequest request, String param)
+                throws ServletException, IOException {
+
+            String bar;
+
+            // Simple if statement that assigns constant to bar on true condition
+            int num = 86;
+            if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+            else bar = param;
+
+            return bar;
+        }
+    } // end innerclass Test
+} // end DataflowThruInnerClass
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01822.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01822.java
new file mode 100644
index 0000000000000000000000000000000000000000..023f04e9e343a2cbe5eba0b40a48c1093168d121
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01822.java	
@@ -0,0 +1,162 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01822")
+public class BenchmarkTest01822 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01822", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01822.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01822")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map20550 = new java.util.HashMap<String, Object>();
+        map20550.put("keyA-20550", "a-Value"); // put some stuff in the collection
+        map20550.put("keyB-20550", param); // put it in a collection
+        map20550.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map20550.get("keyB-20550"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01823.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01823.java
new file mode 100644
index 0000000000000000000000000000000000000000..ede595f4bf1b5b9166645a8713c52cbf60e54275
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01823.java	
@@ -0,0 +1,162 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01823")
+public class BenchmarkTest01823 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01823", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01823.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01823")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01824.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01824.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b44c8c38e9741740c0afd63e39d53927eb2c728
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01824.java	
@@ -0,0 +1,158 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01824")
+public class BenchmarkTest01824 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01824", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01824.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01824")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01825.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01825.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c139b9a073a87e897301b7decdf9760448cf709
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01825.java	
@@ -0,0 +1,163 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01825")
+public class BenchmarkTest01825 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01825", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01825.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01825")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01826.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01826.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d9b899e2e597099949fd3714deefb0d0995b428
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01826.java	
@@ -0,0 +1,164 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01826")
+public class BenchmarkTest01826 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01826", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01826.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01826")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map38565 = new java.util.HashMap<String, Object>();
+        map38565.put("keyA-38565", "a_Value"); // put some stuff in the collection
+        map38565.put("keyB-38565", param); // put it in a collection
+        map38565.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map38565.get("keyB-38565"); // get it back out
+        bar = (String) map38565.get("keyA-38565"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01827.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01827.java
new file mode 100644
index 0000000000000000000000000000000000000000..24a35a091ea0590741bf38d169e0cd6e9ecdf483
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01827.java	
@@ -0,0 +1,177 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01827")
+public class BenchmarkTest01827 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01827", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01827.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01827")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01828.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01828.java
new file mode 100644
index 0000000000000000000000000000000000000000..9480b686b7dfd4fa13a34af14e1af80f4d253524
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01828.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01828")
+public class BenchmarkTest01828 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01828", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01828.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01828")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz6675 = new StringBuilder(param);
+        String bar = sbxyz6675.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01829.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01829.java
new file mode 100644
index 0000000000000000000000000000000000000000..80243f0fb92b95245421cbe8508fea11bdc925bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01829.java	
@@ -0,0 +1,138 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01829")
+public class BenchmarkTest01829 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01829", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01829.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01829")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a60792 = param; // assign
+        StringBuilder b60792 = new StringBuilder(a60792); // stick in stringbuilder
+        b60792.append(" SafeStuff"); // append some safe content
+        b60792.replace(
+                b60792.length() - "Chars".length(),
+                b60792.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map60792 = new java.util.HashMap<String, Object>();
+        map60792.put("key60792", b60792.toString()); // put in a collection
+        String c60792 = (String) map60792.get("key60792"); // get it back out
+        String d60792 = c60792.substring(0, c60792.length() - 1); // extract most of it
+        String e60792 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d60792.getBytes()))); // B64 encode and decode it
+        String f60792 = e60792.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f60792); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01830.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01830.java
new file mode 100644
index 0000000000000000000000000000000000000000..53e2d0ddce0f4c8f53def054d46caa3f85686688
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01830.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01830")
+public class BenchmarkTest01830 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01830", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/crypto-02/BenchmarkTest01830.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01830")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01831.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01831.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f7780e99e0a683ae42cbee08a7f0f05fe6d2596
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01831.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01831")
+public class BenchmarkTest01831 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01831", "Ms+Bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/ldapi-00/BenchmarkTest01831.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01831")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01832.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01832.java
new file mode 100644
index 0000000000000000000000000000000000000000..e603c94c4ddc7218bb938d93fe1f87d57ef41c2f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01832.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01832")
+public class BenchmarkTest01832 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01832", "Ms+Bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/ldapi-00/BenchmarkTest01832.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01832")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01833.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01833.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2e3fa1bfa60ec2ae47a8b490524f6ee98a49629
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01833.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01833")
+public class BenchmarkTest01833 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01833", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01833.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01833")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map9325 = new java.util.HashMap<String, Object>();
+        map9325.put("keyA-9325", "a-Value"); // put some stuff in the collection
+        map9325.put("keyB-9325", param); // put it in a collection
+        map9325.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map9325.get("keyB-9325"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01834.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01834.java
new file mode 100644
index 0000000000000000000000000000000000000000..e044106e383e3a238b12ee44dc8d4f894cb39fb2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01834.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01834")
+public class BenchmarkTest01834 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01834", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01834.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01834")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01835.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01835.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab72609160e4212c43415a4ea9b8d082f4d72101
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01835.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01835")
+public class BenchmarkTest01835 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01835", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01835.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01835")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01836.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01836.java
new file mode 100644
index 0000000000000000000000000000000000000000..d0557196f1e3a55cc9fc74c1c0b75010311ac888
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01836.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01836")
+public class BenchmarkTest01836 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01836", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01836.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01836")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map78713 = new java.util.HashMap<String, Object>();
+        map78713.put("keyA-78713", "a-Value"); // put some stuff in the collection
+        map78713.put("keyB-78713", param); // put it in a collection
+        map78713.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map78713.get("keyB-78713"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01837.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01837.java
new file mode 100644
index 0000000000000000000000000000000000000000..3cf4c8f609f22b8c25fc20630914aaf6962f9c9c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01837.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01837")
+public class BenchmarkTest01837 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01837", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01837.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01837")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01838.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01838.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9e1ec1ff21634690d64183095e28bcbca9f7b57
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01838.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01838")
+public class BenchmarkTest01838 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01838", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01838.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01838")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01839.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01839.java
new file mode 100644
index 0000000000000000000000000000000000000000..238bd33d91d1f15a251aeffb72c37a15d743aabf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01839.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01839")
+public class BenchmarkTest01839 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01839", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01839.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01839")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01840.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01840.java
new file mode 100644
index 0000000000000000000000000000000000000000..462b87d5c486b4a86fa2deccb5440973dc7b84fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01840.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01840")
+public class BenchmarkTest01840 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01840", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01840.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01840")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01841.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01841.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ca11d7df4e8de07134fee733337fb4880c9d687
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01841.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01841")
+public class BenchmarkTest01841 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01841", "FileName");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/pathtraver-02/BenchmarkTest01841.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01841")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a14546 = param; // assign
+        StringBuilder b14546 = new StringBuilder(a14546); // stick in stringbuilder
+        b14546.append(" SafeStuff"); // append some safe content
+        b14546.replace(
+                b14546.length() - "Chars".length(),
+                b14546.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map14546 = new java.util.HashMap<String, Object>();
+        map14546.put("key14546", b14546.toString()); // put in a collection
+        String c14546 = (String) map14546.get("key14546"); // get it back out
+        String d14546 = c14546.substring(0, c14546.length() - 1); // extract most of it
+        String e14546 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d14546.getBytes()))); // B64 encode and decode it
+        String f14546 = e14546.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g14546 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g14546); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01842.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01842.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a79e18df996582b023614b486727c9430fef0de
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01842.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01842")
+public class BenchmarkTest01842 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01842", "anything");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01842.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01842")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01843.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01843.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8068071c0fb63965f53905075b0755824dd86bd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01843.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01843")
+public class BenchmarkTest01843 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01843", "anything");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01843.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01843")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01844.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01844.java
new file mode 100644
index 0000000000000000000000000000000000000000..449d73f42163fb4cfb5dddba0e50014f0ecb5158
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01844.java	
@@ -0,0 +1,140 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01844")
+public class BenchmarkTest01844 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01844", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-02/BenchmarkTest01844.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01844")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a37183 = param; // assign
+        StringBuilder b37183 = new StringBuilder(a37183); // stick in stringbuilder
+        b37183.append(" SafeStuff"); // append some safe content
+        b37183.replace(
+                b37183.length() - "Chars".length(),
+                b37183.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map37183 = new java.util.HashMap<String, Object>();
+        map37183.put("key37183", b37183.toString()); // put in a collection
+        String c37183 = (String) map37183.get("key37183"); // get it back out
+        String d37183 = c37183.substring(0, c37183.length() - 1); // extract most of it
+        String e37183 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d37183.getBytes()))); // B64 encode and decode it
+        String f37183 = e37183.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g37183 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g37183); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01845.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01845.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8a4d9defa11e79c6e55f7fee5cd0933fc22dae1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01845.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01845")
+public class BenchmarkTest01845 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01845", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-02/BenchmarkTest01845.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01845")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01846.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01846.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b4c58785c64eb539433850c2280ec58802de700
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01846.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01846")
+public class BenchmarkTest01846 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01846", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-02/BenchmarkTest01846.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01846")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01847.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01847.java
new file mode 100644
index 0000000000000000000000000000000000000000..1bb297d7123ffa59e9b094770ff26764daba6c49
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01847.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01847")
+public class BenchmarkTest01847 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01847", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-02/BenchmarkTest01847.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01847")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01848.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01848.java
new file mode 100644
index 0000000000000000000000000000000000000000..a0648fcad678f58b03002f2cde0579aa812f8f73
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01848.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01848")
+public class BenchmarkTest01848 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01848", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-02/BenchmarkTest01848.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01848")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01849.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01849.java
new file mode 100644
index 0000000000000000000000000000000000000000..c465e8fb6b208492e5b44fe8c7bdcecba3cff0a3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01849.java	
@@ -0,0 +1,133 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01849")
+public class BenchmarkTest01849 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01849", "someSecret");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/hash-02/BenchmarkTest01849.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01849")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a45344 = param; // assign
+        StringBuilder b45344 = new StringBuilder(a45344); // stick in stringbuilder
+        b45344.append(" SafeStuff"); // append some safe content
+        b45344.replace(
+                b45344.length() - "Chars".length(),
+                b45344.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map45344 = new java.util.HashMap<String, Object>();
+        map45344.put("key45344", b45344.toString()); // put in a collection
+        String c45344 = (String) map45344.get("key45344"); // get it back out
+        String d45344 = c45344.substring(0, c45344.length() - 1); // extract most of it
+        String e45344 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d45344.getBytes()))); // B64 encode and decode it
+        String f45344 = e45344.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g45344 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g45344); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01850.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01850.java
new file mode 100644
index 0000000000000000000000000000000000000000..28c132a8705e176cb7aead5f41dce71f88f39062
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01850.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01850")
+public class BenchmarkTest01850 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01850", "ECHOOO");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-02/BenchmarkTest01850.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01850")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01851.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01851.java
new file mode 100644
index 0000000000000000000000000000000000000000..3472012f49595bd10fcbd54e6b6c24b5ab801096
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01851.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01851")
+public class BenchmarkTest01851 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01851", "ECHOOO");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-02/BenchmarkTest01851.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01851")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01852.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01852.java
new file mode 100644
index 0000000000000000000000000000000000000000..1facba0b072fe4dd1460b782d2584ac53398e50a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01852.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01852")
+public class BenchmarkTest01852 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01852", "ECHOOO");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-02/BenchmarkTest01852.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01852")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01853.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01853.java
new file mode 100644
index 0000000000000000000000000000000000000000..8498624010fb8c469c97fcd9762a6500de74d541
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01853.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01853")
+public class BenchmarkTest01853 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01853", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01853.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01853")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01854.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01854.java
new file mode 100644
index 0000000000000000000000000000000000000000..185720f2d25c636065c5926cf665c56acbd353b7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01854.java	
@@ -0,0 +1,127 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01854")
+public class BenchmarkTest01854 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01854", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01854.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01854")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a34242 = param; // assign
+        StringBuilder b34242 = new StringBuilder(a34242); // stick in stringbuilder
+        b34242.append(" SafeStuff"); // append some safe content
+        b34242.replace(
+                b34242.length() - "Chars".length(),
+                b34242.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map34242 = new java.util.HashMap<String, Object>();
+        map34242.put("key34242", b34242.toString()); // put in a collection
+        String c34242 = (String) map34242.get("key34242"); // get it back out
+        String d34242 = c34242.substring(0, c34242.length() - 1); // extract most of it
+        String e34242 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d34242.getBytes()))); // B64 encode and decode it
+        String f34242 = e34242.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g34242 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g34242); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01855.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01855.java
new file mode 100644
index 0000000000000000000000000000000000000000..33a36719fb82be31369dfe0eabbfcd9c4f224bd2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01855.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01855")
+public class BenchmarkTest01855 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01855", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01855.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01855")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01856.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01856.java
new file mode 100644
index 0000000000000000000000000000000000000000..6927b711b99e3a24a270a7464b24b9eab969ae10
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01856.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01856")
+public class BenchmarkTest01856 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01856", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01856.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01856")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01857.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01857.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff26b1c9e75a57e4019b3f55e3904602db3bf2df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01857.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01857")
+public class BenchmarkTest01857 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01857", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01857.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01857")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01858.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01858.java
new file mode 100644
index 0000000000000000000000000000000000000000..975cbc971317e92942d13f9277fe7ed7f91c568b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01858.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01858")
+public class BenchmarkTest01858 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01858", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01858.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01858")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map95052 = new java.util.HashMap<String, Object>();
+        map95052.put("keyA-95052", "a_Value"); // put some stuff in the collection
+        map95052.put("keyB-95052", param); // put it in a collection
+        map95052.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map95052.get("keyB-95052"); // get it back out
+        bar = (String) map95052.get("keyA-95052"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01859.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01859.java
new file mode 100644
index 0000000000000000000000000000000000000000..8964d616a437b979d1d270218b264385188b1ba1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01859.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01859")
+public class BenchmarkTest01859 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01859", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01859.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01859")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01860.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01860.java
new file mode 100644
index 0000000000000000000000000000000000000000..1cd089058003be440ea82a65d55c90fe58bfbac2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01860.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01860")
+public class BenchmarkTest01860 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01860", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01860.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01860")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01861.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01861.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1f51da2ae71d4675b44f058ec1e60ed91f36ebf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01861.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01861")
+public class BenchmarkTest01861 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01861", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/securecookie-00/BenchmarkTest01861.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01861")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01862.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01862.java
new file mode 100644
index 0000000000000000000000000000000000000000..2967490ea83da76d47ba10369989d54b3424bd8a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01862.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01862")
+public class BenchmarkTest01862 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01862", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/securecookie-00/BenchmarkTest01862.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01862")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01863.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01863.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4ec6b5851286e3205a20fe7520636d2bdc09b2d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01863.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01863")
+public class BenchmarkTest01863 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01863", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/securecookie-00/BenchmarkTest01863.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01863")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01864.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01864.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2dad03912d421f76e992ece0014566a803b3dd0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01864.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01864")
+public class BenchmarkTest01864 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01864", "ls");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-02/BenchmarkTest01864.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01864")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01865.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01865.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b37758c71ddee226348f925d5d0152539c70a01
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01865.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01865")
+public class BenchmarkTest01865 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01865", "ls");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/cmdi-02/BenchmarkTest01865.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01865")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01866.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01866.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb7c339445a54878c0479a9a01f6f5afc378e9df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01866.java	
@@ -0,0 +1,121 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01866")
+public class BenchmarkTest01866 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01866", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01866.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01866")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01867.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01867.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8f37164fc0374c0df3ce3e33534d1b0d09410d7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01867.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01867")
+public class BenchmarkTest01867 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01867", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01867.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01867")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map94996 = new java.util.HashMap<String, Object>();
+        map94996.put("keyA-94996", "a_Value"); // put some stuff in the collection
+        map94996.put("keyB-94996", param); // put it in a collection
+        map94996.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map94996.get("keyB-94996"); // get it back out
+        bar = (String) map94996.get("keyA-94996"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01868.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01868.java
new file mode 100644
index 0000000000000000000000000000000000000000..46f7478df2ecd3d1b91232fe8eb972d26abf07dd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01868.java	
@@ -0,0 +1,130 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01868")
+public class BenchmarkTest01868 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01868", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01868.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01868")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01869.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01869.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7d9233955bfca9e1f25ee23d905b70ccab8929d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01869.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01869")
+public class BenchmarkTest01869 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01869", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01869.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01869")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01870.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01870.java
new file mode 100644
index 0000000000000000000000000000000000000000..cfefac286d17bd7e5fea6ac59968bbc810ed6395
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01870.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01870")
+public class BenchmarkTest01870 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01870", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01870.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01870")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01871.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01871.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a1e4da095197eac756772bce67095c851aba333
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01871.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01871")
+public class BenchmarkTest01871 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01871", "whatever");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/weakrand-04/BenchmarkTest01871.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01871")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz52473 = new StringBuilder(param);
+            bar = sbxyz52473.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01872.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01872.java
new file mode 100644
index 0000000000000000000000000000000000000000..45c2eb54c4f699c6a150376c891a41de9d4c0847
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01872.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01872")
+public class BenchmarkTest01872 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01872", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-01/BenchmarkTest01872.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01872")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01873.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01873.java
new file mode 100644
index 0000000000000000000000000000000000000000..98885741fb59de1f6948459676723caad5bbfd48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01873.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01873")
+public class BenchmarkTest01873 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01873", "my_user_id");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-01/BenchmarkTest01873.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01873")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01874.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01874.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d1376f1aadec0c0b3f5e501262b1ff7adc3d01b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01874.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01874")
+public class BenchmarkTest01874 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01874", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-01/BenchmarkTest01874.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01874")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01875.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01875.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f127eef0f7d3b280c40b1b143606b81683c8a9a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01875.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01875")
+public class BenchmarkTest01875 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01875", "color");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-01/BenchmarkTest01875.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01875")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01876.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01876.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6119eac76d954fd606ee533ce95e3dac6bdf630
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01876.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01876")
+public class BenchmarkTest01876 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01876", "my_userid");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/trustbound-01/BenchmarkTest01876.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01876")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01877.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01877.java
new file mode 100644
index 0000000000000000000000000000000000000000..d916e54bab9deff1e7aa5eb45c7192f2ea2ad9a4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01877.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01877")
+public class BenchmarkTest01877 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie(
+                        "BenchmarkTest01877", "verifyUserPassword%28%27foo%27%2C%27bar%27%29");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01877.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01877")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01878.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01878.java
new file mode 100644
index 0000000000000000000000000000000000000000..94cd7132534b5f3507d19330964a3b1d5411e1ae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01878.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01878")
+public class BenchmarkTest01878 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01878", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01878.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01878")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01879.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01879.java
new file mode 100644
index 0000000000000000000000000000000000000000..8dd08ac0d2baaffc33fd8f9682235906c20fb833
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01879.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01879")
+public class BenchmarkTest01879 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01879", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01879.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01879")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01880.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01880.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c77671655a0bfa24762084422980aadf001ad1d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01880.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01880")
+public class BenchmarkTest01880 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01880", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01880.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01880")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map99153 = new java.util.HashMap<String, Object>();
+        map99153.put("keyA-99153", "a_Value"); // put some stuff in the collection
+        map99153.put("keyB-99153", param); // put it in a collection
+        map99153.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map99153.get("keyB-99153"); // get it back out
+        bar = (String) map99153.get("keyA-99153"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01881.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01881.java
new file mode 100644
index 0000000000000000000000000000000000000000..e684bebeef4cba1a2d0e61fffb5007251cc4678d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01881.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01881")
+public class BenchmarkTest01881 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01881", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01881.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01881")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map20027 = new java.util.HashMap<String, Object>();
+        map20027.put("keyA-20027", "a-Value"); // put some stuff in the collection
+        map20027.put("keyB-20027", param); // put it in a collection
+        map20027.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map20027.get("keyB-20027"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01882.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01882.java
new file mode 100644
index 0000000000000000000000000000000000000000..03b053f5934d17039e4a3a4532bab1f763b37cc2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01882.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01882")
+public class BenchmarkTest01882 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01882", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01882.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01882")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map67948 = new java.util.HashMap<String, Object>();
+        map67948.put("keyA-67948", "a-Value"); // put some stuff in the collection
+        map67948.put("keyB-67948", param); // put it in a collection
+        map67948.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map67948.get("keyB-67948"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01883.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01883.java
new file mode 100644
index 0000000000000000000000000000000000000000..e3eb68998283dc5481c58e4dd7799c02a1ad3301
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01883.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01883")
+public class BenchmarkTest01883 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01883", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01883.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01883")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01884.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01884.java
new file mode 100644
index 0000000000000000000000000000000000000000..7ef1ddaf2ed1d45aea2cae1bb94d998716fb9a55
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01884.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01884")
+public class BenchmarkTest01884 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01884", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01884.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01884")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01885.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01885.java
new file mode 100644
index 0000000000000000000000000000000000000000..13cbe5294eb7439f541357aef6fff92b2bafdb6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01885.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01885")
+public class BenchmarkTest01885 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01885", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01885.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01885")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01886.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01886.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c2b4784e8d322b2e13fefa0b4fdb30e5d21a692
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01886.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01886")
+public class BenchmarkTest01886 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01886", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01886.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01886")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a16884 = param; // assign
+        StringBuilder b16884 = new StringBuilder(a16884); // stick in stringbuilder
+        b16884.append(" SafeStuff"); // append some safe content
+        b16884.replace(
+                b16884.length() - "Chars".length(),
+                b16884.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map16884 = new java.util.HashMap<String, Object>();
+        map16884.put("key16884", b16884.toString()); // put in a collection
+        String c16884 = (String) map16884.get("key16884"); // get it back out
+        String d16884 = c16884.substring(0, c16884.length() - 1); // extract most of it
+        String e16884 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d16884.getBytes()))); // B64 encode and decode it
+        String f16884 = e16884.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g16884 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g16884); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01887.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01887.java
new file mode 100644
index 0000000000000000000000000000000000000000..186577c0e5aeb3348ec2f89fbc150ec1cb8541f6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01887.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01887")
+public class BenchmarkTest01887 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01887", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01887.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01887")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01888.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01888.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4677d58a1d1e7623161a812af3278e60b70b569
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01888.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01888")
+public class BenchmarkTest01888 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01888", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01888.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01888")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01889.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01889.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb4eb477f557681cfd7f634cc0baac811480cffd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01889.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01889")
+public class BenchmarkTest01889 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01889", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01889.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01889")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01890.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01890.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f3f0051156f34f036b3b3949e3bfdc8e39b38ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01890.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01890")
+public class BenchmarkTest01890 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01890", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01890.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01890")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01891.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01891.java
new file mode 100644
index 0000000000000000000000000000000000000000..72ea92e35bd994f67ffb57b5bf334e7ef6fd536c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01891.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01891")
+public class BenchmarkTest01891 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01891", "bar");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/sqli-04/BenchmarkTest01891.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01891")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01892.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01892.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6710ad8c65d051dc0d97e24905935c6d63506bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01892.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01892")
+public class BenchmarkTest01892 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01892", "2222");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/xpathi-00/BenchmarkTest01892.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01892")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map3451 = new java.util.HashMap<String, Object>();
+        map3451.put("keyA-3451", "a-Value"); // put some stuff in the collection
+        map3451.put("keyB-3451", param); // put it in a collection
+        map3451.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map3451.get("keyB-3451"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01893.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01893.java
new file mode 100644
index 0000000000000000000000000000000000000000..b642b459dc944954e2c714b813b2d91530677667
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01893.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01893")
+public class BenchmarkTest01893 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01893", "2222");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/xpathi-00/BenchmarkTest01893.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01893")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01894.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01894.java
new file mode 100644
index 0000000000000000000000000000000000000000..32246795b843795f02799f16878953ed786609f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01894.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01894")
+public class BenchmarkTest01894 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+        javax.servlet.http.Cookie userCookie =
+                new javax.servlet.http.Cookie("BenchmarkTest01894", "2222");
+        userCookie.setMaxAge(60 * 3); // Store cookie for 3 minutes
+        userCookie.setSecure(true);
+        userCookie.setPath(request.getRequestURI());
+        userCookie.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+        response.addCookie(userCookie);
+        javax.servlet.RequestDispatcher rd =
+                request.getRequestDispatcher("/xpathi-00/BenchmarkTest01894.html");
+        rd.include(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        javax.servlet.http.Cookie[] theCookies = request.getCookies();
+
+        String param = "noCookieValueSupplied";
+        if (theCookies != null) {
+            for (javax.servlet.http.Cookie theCookie : theCookies) {
+                if (theCookie.getName().equals("BenchmarkTest01894")) {
+                    param = java.net.URLDecoder.decode(theCookie.getValue(), "UTF-8");
+                    break;
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01895.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01895.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e99b0ce1c76055ffa1bf6aae431834d7c34aadc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01895.java	
@@ -0,0 +1,152 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01895")
+public class BenchmarkTest01895 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01895") != null) {
+            param = request.getHeader("BenchmarkTest01895");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01896.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01896.java
new file mode 100644
index 0000000000000000000000000000000000000000..5876bf2c27667459ca5c15a7f1ab2f955c726ba3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01896.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01896")
+public class BenchmarkTest01896 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01896") != null) {
+            param = request.getHeader("BenchmarkTest01896");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01897.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01897.java
new file mode 100644
index 0000000000000000000000000000000000000000..aad194a04e0844166fbcd789e39d86469ea06667
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01897.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01897")
+public class BenchmarkTest01897 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01897") != null) {
+            param = request.getHeader("BenchmarkTest01897");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01898.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01898.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8f863d322781867f0a4fb84f751653b02e33be1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01898.java	
@@ -0,0 +1,132 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01898")
+public class BenchmarkTest01898 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01898") != null) {
+            param = request.getHeader("BenchmarkTest01898");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01899.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01899.java
new file mode 100644
index 0000000000000000000000000000000000000000..3153bada662773a114ebe1a6573af14b9cb7bbec
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01899.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01899")
+public class BenchmarkTest01899 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01899") != null) {
+            param = request.getHeader("BenchmarkTest01899");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01900.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01900.java
new file mode 100644
index 0000000000000000000000000000000000000000..65f918f72b6ed73ab78dfac024dd4f59a51aaa7c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01900.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01900")
+public class BenchmarkTest01900 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01900") != null) {
+            param = request.getHeader("BenchmarkTest01900");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01901.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01901.java
new file mode 100644
index 0000000000000000000000000000000000000000..20a37faa357a2ccbef9772da52e1ff9b2b5d9a73
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01901.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01901")
+public class BenchmarkTest01901 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01901") != null) {
+            param = request.getHeader("BenchmarkTest01901");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz69308 = new StringBuilder(param);
+        String bar = sbxyz69308.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01902.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01902.java
new file mode 100644
index 0000000000000000000000000000000000000000..364acf1d2269b1760c48b88bf976264d054b70be
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01902.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01902")
+public class BenchmarkTest01902 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01902") != null) {
+            param = request.getHeader("BenchmarkTest01902");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01903.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01903.java
new file mode 100644
index 0000000000000000000000000000000000000000..bcb912813051abc1c7b8ac43cf042c11b366da62
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01903.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01903")
+public class BenchmarkTest01903 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01903") != null) {
+            param = request.getHeader("BenchmarkTest01903");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01904.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01904.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9b86298c210db35b55c115b057513e4a8069118
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01904.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01904")
+public class BenchmarkTest01904 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01904") != null) {
+            param = request.getHeader("BenchmarkTest01904");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map13742 = new java.util.HashMap<String, Object>();
+        map13742.put("keyA-13742", "a-Value"); // put some stuff in the collection
+        map13742.put("keyB-13742", param); // put it in a collection
+        map13742.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map13742.get("keyB-13742"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01905.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01905.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d8869ac266af21bfbd06a64b30c7d3281da8adb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01905.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01905")
+public class BenchmarkTest01905 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01905") != null) {
+            param = request.getHeader("BenchmarkTest01905");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map33587 = new java.util.HashMap<String, Object>();
+        map33587.put("keyA-33587", "a_Value"); // put some stuff in the collection
+        map33587.put("keyB-33587", param); // put it in a collection
+        map33587.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map33587.get("keyB-33587"); // get it back out
+        bar = (String) map33587.get("keyA-33587"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01906.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01906.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc168022cd83f358021e49d3a58e6ce168c6d707
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01906.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01906")
+public class BenchmarkTest01906 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01906") != null) {
+            param = request.getHeader("BenchmarkTest01906");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01907.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01907.java
new file mode 100644
index 0000000000000000000000000000000000000000..2cb2db1913b6210b1b064db5c0fa89abb39aba91
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01907.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01907")
+public class BenchmarkTest01907 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01907") != null) {
+            param = request.getHeader("BenchmarkTest01907");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01908.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01908.java
new file mode 100644
index 0000000000000000000000000000000000000000..99ebadf0ad76caaabd39d2317860450bb7f51a49
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01908.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01908")
+public class BenchmarkTest01908 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01908") != null) {
+            param = request.getHeader("BenchmarkTest01908");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01909.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01909.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc9d6b95408bf9169dcc95fc987f15583ec42e88
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01909.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest01909")
+public class BenchmarkTest01909 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01909") != null) {
+            param = request.getHeader("BenchmarkTest01909");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map30748 = new java.util.HashMap<String, Object>();
+        map30748.put("keyA-30748", "a_Value"); // put some stuff in the collection
+        map30748.put("keyB-30748", param); // put it in a collection
+        map30748.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map30748.get("keyB-30748"); // get it back out
+        bar = (String) map30748.get("keyA-30748"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01910.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01910.java
new file mode 100644
index 0000000000000000000000000000000000000000..3033188ab9b52a32812c8e9b23357a9c974c8efb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01910.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01910")
+public class BenchmarkTest01910 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01910") != null) {
+            param = request.getHeader("BenchmarkTest01910");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01911.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01911.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9ab9acb7d9794f85190e7d8e56552a1d0355db0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01911.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01911")
+public class BenchmarkTest01911 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01911") != null) {
+            param = request.getHeader("BenchmarkTest01911");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01912.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01912.java
new file mode 100644
index 0000000000000000000000000000000000000000..b81ec995ff20dd797ef2ba619453d850f0a05bc8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01912.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01912")
+public class BenchmarkTest01912 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01912") != null) {
+            param = request.getHeader("BenchmarkTest01912");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01913.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01913.java
new file mode 100644
index 0000000000000000000000000000000000000000..570a77cca11a53e935f29d351d415cf3844c1304
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01913.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01913")
+public class BenchmarkTest01913 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01913") != null) {
+            param = request.getHeader("BenchmarkTest01913");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01914.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01914.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8053ada2a2ade63014cbefa6ce0802939a2406a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01914.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01914")
+public class BenchmarkTest01914 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01915.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01915.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d69bd2776496000b79bb4ab46b7531cdb4c6eff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01915.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01915")
+public class BenchmarkTest01915 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01916.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01916.java
new file mode 100644
index 0000000000000000000000000000000000000000..8122cae7c407cbdac78d8f2acc3932b167ffb202
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01916.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01916")
+public class BenchmarkTest01916 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01917.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01917.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a2f122143422e2ace1a5a4488aba7f7ce8b62bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01917.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01917")
+public class BenchmarkTest01917 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01918.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01918.java
new file mode 100644
index 0000000000000000000000000000000000000000..2f56e8f34674f6a815a7f09712d1da3efcdd0844
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01918.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01918")
+public class BenchmarkTest01918 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01919.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01919.java
new file mode 100644
index 0000000000000000000000000000000000000000..15fc7302a79b63c5e403a97543cd0412f5b44375
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01919.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01919")
+public class BenchmarkTest01919 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01920.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01920.java
new file mode 100644
index 0000000000000000000000000000000000000000..89801f957fa3dd78909f93b041f7b767d2f72377
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01920.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01920")
+public class BenchmarkTest01920 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01921.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01921.java
new file mode 100644
index 0000000000000000000000000000000000000000..f905246cbd5df468a21c2cfa6112141dc2f82004
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01921.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01921")
+public class BenchmarkTest01921 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01922.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01922.java
new file mode 100644
index 0000000000000000000000000000000000000000..801e53a9edb9349f5862f78207503614b4abf6dc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01922.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01922")
+public class BenchmarkTest01922 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01923.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01923.java
new file mode 100644
index 0000000000000000000000000000000000000000..f582d6b489671f8905722aa13c5401e004f458d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01923.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01923")
+public class BenchmarkTest01923 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01924.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01924.java
new file mode 100644
index 0000000000000000000000000000000000000000..efe2b345002fb87db45319d00cde63921d2c0a66
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01924.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01924")
+public class BenchmarkTest01924 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01925.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01925.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1ccc1d0bcb6b706035b120526e3603926a599a8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01925.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01925")
+public class BenchmarkTest01925 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz28389 = new StringBuilder(param);
+            bar = sbxyz28389.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01926.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01926.java
new file mode 100644
index 0000000000000000000000000000000000000000..626f705c3f1bfd80472d44a4a82cee310c2b07bd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01926.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01926")
+public class BenchmarkTest01926 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01927.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01927.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab9b28ec821373b7d0f0bc07cb652419f931fecb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01927.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest01927")
+public class BenchmarkTest01927 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("Referer") != null) {
+            param = request.getHeader("Referer");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01928.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01928.java
new file mode 100644
index 0000000000000000000000000000000000000000..36ed9f6a2981e546c24fe621ecc2ea6d388fd46f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01928.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01928")
+public class BenchmarkTest01928 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01928") != null) {
+            param = request.getHeader("BenchmarkTest01928");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01929.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01929.java
new file mode 100644
index 0000000000000000000000000000000000000000..657cc09e1446a3ae638874d477f2fcd63e524647
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01929.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01929")
+public class BenchmarkTest01929 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01929") != null) {
+            param = request.getHeader("BenchmarkTest01929");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map44 = new java.util.HashMap<String, Object>();
+        map44.put("keyA-44", "a-Value"); // put some stuff in the collection
+        map44.put("keyB-44", param); // put it in a collection
+        map44.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map44.get("keyB-44"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01930.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01930.java
new file mode 100644
index 0000000000000000000000000000000000000000..f766379c0ca544e7725eff60b4df06cc677a77de
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01930.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01930")
+public class BenchmarkTest01930 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01930") != null) {
+            param = request.getHeader("BenchmarkTest01930");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz62502 = new StringBuilder(param);
+        String bar = sbxyz62502.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01931.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01931.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2d33bacbf41481663163693df103fbf82a6fdcd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01931.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01931")
+public class BenchmarkTest01931 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01931") != null) {
+            param = request.getHeader("BenchmarkTest01931");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a40465 = param; // assign
+        StringBuilder b40465 = new StringBuilder(a40465); // stick in stringbuilder
+        b40465.append(" SafeStuff"); // append some safe content
+        b40465.replace(
+                b40465.length() - "Chars".length(),
+                b40465.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map40465 = new java.util.HashMap<String, Object>();
+        map40465.put("key40465", b40465.toString()); // put in a collection
+        String c40465 = (String) map40465.get("key40465"); // get it back out
+        String d40465 = c40465.substring(0, c40465.length() - 1); // extract most of it
+        String e40465 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d40465.getBytes()))); // B64 encode and decode it
+        String f40465 = e40465.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f40465); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01932.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01932.java
new file mode 100644
index 0000000000000000000000000000000000000000..8de9eed404c7132debd615880f2777ac4eb5b580
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01932.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01932")
+public class BenchmarkTest01932 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01932") != null) {
+            param = request.getHeader("BenchmarkTest01932");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01933.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01933.java
new file mode 100644
index 0000000000000000000000000000000000000000..52f6d06fdef9795db81ecce26af222dd1190a91c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01933.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01933")
+public class BenchmarkTest01933 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01933") != null) {
+            param = request.getHeader("BenchmarkTest01933");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01934.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01934.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9c314b6e1739974b9e553b3be164c8e16e3b0f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01934.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01934")
+public class BenchmarkTest01934 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01934") != null) {
+            param = request.getHeader("BenchmarkTest01934");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01935.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01935.java
new file mode 100644
index 0000000000000000000000000000000000000000..83a27e2ff787b4d0e74bb6f643eccd158a6e6152
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01935.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest01935")
+public class BenchmarkTest01935 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01935") != null) {
+            param = request.getHeader("BenchmarkTest01935");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a17785 = param; // assign
+        StringBuilder b17785 = new StringBuilder(a17785); // stick in stringbuilder
+        b17785.append(" SafeStuff"); // append some safe content
+        b17785.replace(
+                b17785.length() - "Chars".length(),
+                b17785.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map17785 = new java.util.HashMap<String, Object>();
+        map17785.put("key17785", b17785.toString()); // put in a collection
+        String c17785 = (String) map17785.get("key17785"); // get it back out
+        String d17785 = c17785.substring(0, c17785.length() - 1); // extract most of it
+        String e17785 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d17785.getBytes()))); // B64 encode and decode it
+        String f17785 = e17785.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f17785); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01936.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01936.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4abb4a8e2d591674e9f73239bd805249b82d15f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01936.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01936")
+public class BenchmarkTest01936 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01936") != null) {
+            param = request.getHeader("BenchmarkTest01936");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01937.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01937.java
new file mode 100644
index 0000000000000000000000000000000000000000..978de203cb01e57d59265b7cf27f044bd288a846
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01937.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01937")
+public class BenchmarkTest01937 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01937") != null) {
+            param = request.getHeader("BenchmarkTest01937");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01938.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01938.java
new file mode 100644
index 0000000000000000000000000000000000000000..49222aac3a2bfbb5d3fe1852342640ac8c79f609
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01938.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01938")
+public class BenchmarkTest01938 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01938") != null) {
+            param = request.getHeader("BenchmarkTest01938");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01939.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01939.java
new file mode 100644
index 0000000000000000000000000000000000000000..803b4e013729da9699a8f10b3c83ed95bf0f00c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01939.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01939")
+public class BenchmarkTest01939 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01939") != null) {
+            param = request.getHeader("BenchmarkTest01939");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01940.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01940.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0a37fc1a6ba713c9e21df55b090cb685b3e8450
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01940.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01940")
+public class BenchmarkTest01940 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01940") != null) {
+            param = request.getHeader("BenchmarkTest01940");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01941.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01941.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c2a5b0acdf525c8c5055efc8cd6b0bed62a6bb8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01941.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01941")
+public class BenchmarkTest01941 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01941") != null) {
+            param = request.getHeader("BenchmarkTest01941");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a20426 = param; // assign
+        StringBuilder b20426 = new StringBuilder(a20426); // stick in stringbuilder
+        b20426.append(" SafeStuff"); // append some safe content
+        b20426.replace(
+                b20426.length() - "Chars".length(),
+                b20426.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map20426 = new java.util.HashMap<String, Object>();
+        map20426.put("key20426", b20426.toString()); // put in a collection
+        String c20426 = (String) map20426.get("key20426"); // get it back out
+        String d20426 = c20426.substring(0, c20426.length() - 1); // extract most of it
+        String e20426 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d20426.getBytes()))); // B64 encode and decode it
+        String f20426 = e20426.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g20426 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g20426); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01942.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01942.java
new file mode 100644
index 0000000000000000000000000000000000000000..acfc2c96582f7609d2eec0f4e4d999a3dde2f688
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01942.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01942")
+public class BenchmarkTest01942 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01942") != null) {
+            param = request.getHeader("BenchmarkTest01942");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01943.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01943.java
new file mode 100644
index 0000000000000000000000000000000000000000..98dcaf5e2b851f7c3cdfafa6c1c07e5c5758de2b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01943.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01943")
+public class BenchmarkTest01943 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01943") != null) {
+            param = request.getHeader("BenchmarkTest01943");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map72345 = new java.util.HashMap<String, Object>();
+        map72345.put("keyA-72345", "a_Value"); // put some stuff in the collection
+        map72345.put("keyB-72345", param); // put it in a collection
+        map72345.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map72345.get("keyB-72345"); // get it back out
+        bar = (String) map72345.get("keyA-72345"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01944.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01944.java
new file mode 100644
index 0000000000000000000000000000000000000000..887b41afca0731dc407244d640750fc38937f186
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01944.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest01944")
+public class BenchmarkTest01944 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01944") != null) {
+            param = request.getHeader("BenchmarkTest01944");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01945.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01945.java
new file mode 100644
index 0000000000000000000000000000000000000000..54c416a26dc50790b1c463fb98b38e4ddc5359aa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01945.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01945")
+public class BenchmarkTest01945 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01945") != null) {
+            param = request.getHeader("BenchmarkTest01945");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01946.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01946.java
new file mode 100644
index 0000000000000000000000000000000000000000..15d29037a3eee00ff303369f1be28ba03f263d65
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01946.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01946")
+public class BenchmarkTest01946 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01946") != null) {
+            param = request.getHeader("BenchmarkTest01946");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01947.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01947.java
new file mode 100644
index 0000000000000000000000000000000000000000..4cbb76b972aaa390e4f8a1e6de0bbc44a8e4d71f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01947.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01947")
+public class BenchmarkTest01947 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01947") != null) {
+            param = request.getHeader("BenchmarkTest01947");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01948.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01948.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba29ec6ed5820d1f90665e092bacfde66a5fef53
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01948.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01948")
+public class BenchmarkTest01948 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01948") != null) {
+            param = request.getHeader("BenchmarkTest01948");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz84277 = new StringBuilder(param);
+            bar = sbxyz84277.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01949.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01949.java
new file mode 100644
index 0000000000000000000000000000000000000000..72a2e6e5bbcff39c6689f4baf6ce7b235f30ba45
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01949.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01949")
+public class BenchmarkTest01949 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01949") != null) {
+            param = request.getHeader("BenchmarkTest01949");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01950.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01950.java
new file mode 100644
index 0000000000000000000000000000000000000000..6a6e5181ea27470bb4ae4f7430582aeacd19212d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01950.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01950")
+public class BenchmarkTest01950 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01950") != null) {
+            param = request.getHeader("BenchmarkTest01950");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map14411 = new java.util.HashMap<String, Object>();
+        map14411.put("keyA-14411", "a-Value"); // put some stuff in the collection
+        map14411.put("keyB-14411", param); // put it in a collection
+        map14411.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map14411.get("keyB-14411"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01951.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01951.java
new file mode 100644
index 0000000000000000000000000000000000000000..e0c70756bd5970c9ee84d40327bc6f97a9d9ac60
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01951.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01951")
+public class BenchmarkTest01951 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01951") != null) {
+            param = request.getHeader("BenchmarkTest01951");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01952.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01952.java
new file mode 100644
index 0000000000000000000000000000000000000000..480520616dda4ba0c40cb825368311fe579dd2ca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01952.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01952")
+public class BenchmarkTest01952 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01952") != null) {
+            param = request.getHeader("BenchmarkTest01952");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01953.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01953.java
new file mode 100644
index 0000000000000000000000000000000000000000..9efa58248149226a45c2817c332da5b66f8661e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01953.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01953")
+public class BenchmarkTest01953 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01953") != null) {
+            param = request.getHeader("BenchmarkTest01953");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01954.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01954.java
new file mode 100644
index 0000000000000000000000000000000000000000..8cd8a59616a8292d73d2ffbdf8023c13832114eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01954.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01954")
+public class BenchmarkTest01954 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01954") != null) {
+            param = request.getHeader("BenchmarkTest01954");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01955.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01955.java
new file mode 100644
index 0000000000000000000000000000000000000000..8732150bb85a47789fc7e6b851577d7b605dba7a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01955.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01955")
+public class BenchmarkTest01955 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01955") != null) {
+            param = request.getHeader("BenchmarkTest01955");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01956.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01956.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6d85175dd46ce4e5465485f226dff695ce0010a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01956.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01956")
+public class BenchmarkTest01956 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01956") != null) {
+            param = request.getHeader("BenchmarkTest01956");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01957.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01957.java
new file mode 100644
index 0000000000000000000000000000000000000000..99f686550c49a64730299bf49e6649fa3d1be1f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01957.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01957")
+public class BenchmarkTest01957 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01957") != null) {
+            param = request.getHeader("BenchmarkTest01957");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01958.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01958.java
new file mode 100644
index 0000000000000000000000000000000000000000..adaf27dbb082ab074a0ab835e4f619afdac12e7f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01958.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01958")
+public class BenchmarkTest01958 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01958") != null) {
+            param = request.getHeader("BenchmarkTest01958");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz15757 = new StringBuilder(param);
+            bar = sbxyz15757.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01959.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01959.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b13b1daf2a2d0a1e18f02bdf99b41c68d5fe2ec
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01959.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01959")
+public class BenchmarkTest01959 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01959") != null) {
+            param = request.getHeader("BenchmarkTest01959");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map4095 = new java.util.HashMap<String, Object>();
+        map4095.put("keyA-4095", "a_Value"); // put some stuff in the collection
+        map4095.put("keyB-4095", param); // put it in a collection
+        map4095.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map4095.get("keyB-4095"); // get it back out
+        bar = (String) map4095.get("keyA-4095"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01960.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01960.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b03485129b0afb00934a3c127a18df3b921dd1a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01960.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest01960")
+public class BenchmarkTest01960 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01960") != null) {
+            param = request.getHeader("BenchmarkTest01960");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01961.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01961.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ea3737004cfd63ac398b270706d883ba02e79ad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01961.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01961")
+public class BenchmarkTest01961 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01961") != null) {
+            param = request.getHeader("BenchmarkTest01961");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a99523 = param; // assign
+        StringBuilder b99523 = new StringBuilder(a99523); // stick in stringbuilder
+        b99523.append(" SafeStuff"); // append some safe content
+        b99523.replace(
+                b99523.length() - "Chars".length(),
+                b99523.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map99523 = new java.util.HashMap<String, Object>();
+        map99523.put("key99523", b99523.toString()); // put in a collection
+        String c99523 = (String) map99523.get("key99523"); // get it back out
+        String d99523 = c99523.substring(0, c99523.length() - 1); // extract most of it
+        String e99523 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d99523.getBytes()))); // B64 encode and decode it
+        String f99523 = e99523.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g99523 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g99523); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01962.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01962.java
new file mode 100644
index 0000000000000000000000000000000000000000..e0d0526db680f7231af892d0a4171045a17c9b63
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01962.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01962")
+public class BenchmarkTest01962 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01962") != null) {
+            param = request.getHeader("BenchmarkTest01962");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01963.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01963.java
new file mode 100644
index 0000000000000000000000000000000000000000..e77dfcfb3d2d0335a9392defa5afcdfffcfda106
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01963.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01963")
+public class BenchmarkTest01963 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01963") != null) {
+            param = request.getHeader("BenchmarkTest01963");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01964.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01964.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bb03f70eb149ba112b8933ba37b6922d0bbd96d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01964.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01964")
+public class BenchmarkTest01964 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01964") != null) {
+            param = request.getHeader("BenchmarkTest01964");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01965.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01965.java
new file mode 100644
index 0000000000000000000000000000000000000000..59148660a1eee840a46923586a17657132b94c09
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01965.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01965")
+public class BenchmarkTest01965 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01965") != null) {
+            param = request.getHeader("BenchmarkTest01965");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01966.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01966.java
new file mode 100644
index 0000000000000000000000000000000000000000..83edeacc2b3ab96b279ab4d005d9cdc6b3f606ea
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01966.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01966")
+public class BenchmarkTest01966 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01966") != null) {
+            param = request.getHeader("BenchmarkTest01966");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01967.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01967.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a54655501d5e479bfe86cc6de9ad506cc928cf3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01967.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01967")
+public class BenchmarkTest01967 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01967") != null) {
+            param = request.getHeader("BenchmarkTest01967");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01968.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01968.java
new file mode 100644
index 0000000000000000000000000000000000000000..72fef4c6762ec91bb0e72ad4f4d43badea2c7c91
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01968.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01968")
+public class BenchmarkTest01968 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01968") != null) {
+            param = request.getHeader("BenchmarkTest01968");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01969.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01969.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b45edb120d77f72a0f3cb6b090544f2a50e36dd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01969.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01969")
+public class BenchmarkTest01969 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01969") != null) {
+            param = request.getHeader("BenchmarkTest01969");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01970.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01970.java
new file mode 100644
index 0000000000000000000000000000000000000000..50dcfb6aaf5dae140b9db38d7f36d252f80836a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01970.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01970")
+public class BenchmarkTest01970 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01970") != null) {
+            param = request.getHeader("BenchmarkTest01970");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01971.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01971.java
new file mode 100644
index 0000000000000000000000000000000000000000..957800472afdb335122123eb19b9b7cf44d3586f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01971.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01971")
+public class BenchmarkTest01971 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01971") != null) {
+            param = request.getHeader("BenchmarkTest01971");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01972.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01972.java
new file mode 100644
index 0000000000000000000000000000000000000000..980e85d252d4b1a5ef2fd5fa27f45600fa4d4977
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01972.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01972")
+public class BenchmarkTest01972 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01972") != null) {
+            param = request.getHeader("BenchmarkTest01972");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01973.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01973.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea2d98afc1eb8b00ef97a50f2d2229a2d0646de7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01973.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest01973")
+public class BenchmarkTest01973 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01973") != null) {
+            param = request.getHeader("BenchmarkTest01973");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01974.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01974.java
new file mode 100644
index 0000000000000000000000000000000000000000..b7513b0938a2fab26ede74a2bcd4197beb463969
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01974.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest01974")
+public class BenchmarkTest01974 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        if (request.getHeader("BenchmarkTest01974") != null) {
+            param = request.getHeader("BenchmarkTest01974");
+        }
+
+        // URL Decode the header value since req.getHeader() doesn't. Unlike req.getParameter().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map11821 = new java.util.HashMap<String, Object>();
+        map11821.put("keyA-11821", "a-Value"); // put some stuff in the collection
+        map11821.put("keyB-11821", param); // put it in a collection
+        map11821.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map11821.get("keyB-11821"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01975.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01975.java
new file mode 100644
index 0000000000000000000000000000000000000000..ab2eede64f8d20e3dff9d5ec72e2ffe80d033938
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01975.java	
@@ -0,0 +1,154 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01975")
+public class BenchmarkTest01975 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01976.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01976.java
new file mode 100644
index 0000000000000000000000000000000000000000..e27d58033c1f11d6ebca9c7d3a6636574b3f5f95
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01976.java	
@@ -0,0 +1,155 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01976")
+public class BenchmarkTest01976 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz47784 = new StringBuilder(param);
+        String bar = sbxyz47784.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01977.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01977.java
new file mode 100644
index 0000000000000000000000000000000000000000..e53b1c164c23255badddc2923439d51c3aab418e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01977.java	
@@ -0,0 +1,173 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01977")
+public class BenchmarkTest01977 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01978.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01978.java
new file mode 100644
index 0000000000000000000000000000000000000000..bdfe3c9da27e3f616eb4c072f0edfb1fa42cbfbc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01978.java	
@@ -0,0 +1,127 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01978")
+public class BenchmarkTest01978 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz6576 = new StringBuilder(param);
+            bar = sbxyz6576.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01979.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01979.java
new file mode 100644
index 0000000000000000000000000000000000000000..0165634abae55fadac9b188b725cf4fa5661fe75
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01979.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01979")
+public class BenchmarkTest01979 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01980.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01980.java
new file mode 100644
index 0000000000000000000000000000000000000000..b08bf9d7d6fcf53273c2731508584e92899148c1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01980.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01980")
+public class BenchmarkTest01980 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz90777 = new StringBuilder(param);
+        String bar = sbxyz90777.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01981.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01981.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c7cce378c0c6d57b5fec3c2e008c853a18eedfa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01981.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01981")
+public class BenchmarkTest01981 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01982.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01982.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f55b66c5ba34e0b899de518bb47557cc2f0ee3d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01982.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest01982")
+public class BenchmarkTest01982 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01983.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01983.java
new file mode 100644
index 0000000000000000000000000000000000000000..f1c4564dc7dafc8f0e76fbd6f001249c64e62bb7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01983.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01983")
+public class BenchmarkTest01983 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01984.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01984.java
new file mode 100644
index 0000000000000000000000000000000000000000..129a2785d118b2fd7736673f72afe386ff3dce8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01984.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01984")
+public class BenchmarkTest01984 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map95438 = new java.util.HashMap<String, Object>();
+        map95438.put("keyA-95438", "a_Value"); // put some stuff in the collection
+        map95438.put("keyB-95438", param); // put it in a collection
+        map95438.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map95438.get("keyB-95438"); // get it back out
+        bar = (String) map95438.get("keyA-95438"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01985.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01985.java
new file mode 100644
index 0000000000000000000000000000000000000000..122a62aef1dff57b4d421602f1e083e2073a174c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01985.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01985")
+public class BenchmarkTest01985 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01986.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01986.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a39fcc1f54f09015a1531ee43cc355acca0a620
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01986.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01986")
+public class BenchmarkTest01986 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map83331 = new java.util.HashMap<String, Object>();
+        map83331.put("keyA-83331", "a_Value"); // put some stuff in the collection
+        map83331.put("keyB-83331", param); // put it in a collection
+        map83331.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map83331.get("keyB-83331"); // get it back out
+        bar = (String) map83331.get("keyA-83331"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01987.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01987.java
new file mode 100644
index 0000000000000000000000000000000000000000..84ca00d00f152b2b0d5042921c1d1a7831b44771
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01987.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01987")
+public class BenchmarkTest01987 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01988.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01988.java
new file mode 100644
index 0000000000000000000000000000000000000000..15e5f0696f65dc5fc6c2fa191ffbd266eac596f7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01988.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01988")
+public class BenchmarkTest01988 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01989.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01989.java
new file mode 100644
index 0000000000000000000000000000000000000000..40445a36e05effa2b30a2dd48528fe094df7f39d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01989.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01989")
+public class BenchmarkTest01989 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01990.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01990.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f1a167e4683b089366c78cecb4ab08d67736bb7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01990.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01990")
+public class BenchmarkTest01990 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01991.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01991.java
new file mode 100644
index 0000000000000000000000000000000000000000..b11e2c510c872717a31928c78705a16d9c093a46
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01991.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest01991")
+public class BenchmarkTest01991 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a81108 = param; // assign
+        StringBuilder b81108 = new StringBuilder(a81108); // stick in stringbuilder
+        b81108.append(" SafeStuff"); // append some safe content
+        b81108.replace(
+                b81108.length() - "Chars".length(),
+                b81108.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map81108 = new java.util.HashMap<String, Object>();
+        map81108.put("key81108", b81108.toString()); // put in a collection
+        String c81108 = (String) map81108.get("key81108"); // get it back out
+        String d81108 = c81108.substring(0, c81108.length() - 1); // extract most of it
+        String e81108 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d81108.getBytes()))); // B64 encode and decode it
+        String f81108 = e81108.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g81108 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g81108); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01992.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01992.java
new file mode 100644
index 0000000000000000000000000000000000000000..57aa027c3dda60be98ca60e9235b24bbf4b3feb7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01992.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01992")
+public class BenchmarkTest01992 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a82010 = param; // assign
+        StringBuilder b82010 = new StringBuilder(a82010); // stick in stringbuilder
+        b82010.append(" SafeStuff"); // append some safe content
+        b82010.replace(
+                b82010.length() - "Chars".length(),
+                b82010.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map82010 = new java.util.HashMap<String, Object>();
+        map82010.put("key82010", b82010.toString()); // put in a collection
+        String c82010 = (String) map82010.get("key82010"); // get it back out
+        String d82010 = c82010.substring(0, c82010.length() - 1); // extract most of it
+        String e82010 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d82010.getBytes()))); // B64 encode and decode it
+        String f82010 = e82010.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f82010); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01993.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01993.java
new file mode 100644
index 0000000000000000000000000000000000000000..87e9e253aa71599b77e9e3e2f371020a5040ed03
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01993.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01993")
+public class BenchmarkTest01993 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01994.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01994.java
new file mode 100644
index 0000000000000000000000000000000000000000..9463b81d7c56e977712367878041846aba9d879e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01994.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01994")
+public class BenchmarkTest01994 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01995.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01995.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d0d1a5d47ad1c88c14fe042121e4dcf027f0031
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01995.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01995")
+public class BenchmarkTest01995 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a33633 = param; // assign
+        StringBuilder b33633 = new StringBuilder(a33633); // stick in stringbuilder
+        b33633.append(" SafeStuff"); // append some safe content
+        b33633.replace(
+                b33633.length() - "Chars".length(),
+                b33633.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map33633 = new java.util.HashMap<String, Object>();
+        map33633.put("key33633", b33633.toString()); // put in a collection
+        String c33633 = (String) map33633.get("key33633"); // get it back out
+        String d33633 = c33633.substring(0, c33633.length() - 1); // extract most of it
+        String e33633 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d33633.getBytes()))); // B64 encode and decode it
+        String f33633 = e33633.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g33633 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g33633); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01996.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01996.java
new file mode 100644
index 0000000000000000000000000000000000000000..eeecfebe907a12975f6a69d52dc887ecedf58c01
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01996.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01996")
+public class BenchmarkTest01996 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01997.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01997.java
new file mode 100644
index 0000000000000000000000000000000000000000..8957a6fb6a3a4f169fe1bbbf7f6118d8816e100d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01997.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01997")
+public class BenchmarkTest01997 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01998.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01998.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9a230fe13b176267c55715cc456a2d676d5bb8e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01998.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest01998")
+public class BenchmarkTest01998 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01999.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01999.java
new file mode 100644
index 0000000000000000000000000000000000000000..884c835b470657d2a856a66dfe9bc4f6ccf29c21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest01999.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest01999")
+public class BenchmarkTest01999 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map28743 = new java.util.HashMap<String, Object>();
+        map28743.put("keyA-28743", "a-Value"); // put some stuff in the collection
+        map28743.put("keyB-28743", param); // put it in a collection
+        map28743.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map28743.get("keyB-28743"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02000.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02000.java
new file mode 100644
index 0000000000000000000000000000000000000000..20614d1859dced0fa41d865a5410c11f616462fb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02000.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02000")
+public class BenchmarkTest02000 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02001.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02001.java
new file mode 100644
index 0000000000000000000000000000000000000000..662b70b83f611947d37a036f5044cef9311ee81c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02001.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02001")
+public class BenchmarkTest02001 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02002.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02002.java
new file mode 100644
index 0000000000000000000000000000000000000000..6296a8ec96839185b2717b4803b7c1c6cf440cb2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02002.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02002")
+public class BenchmarkTest02002 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02003.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02003.java
new file mode 100644
index 0000000000000000000000000000000000000000..05a6a957b9b058cf4a8b937fdbb3fe9827e841a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02003.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02003")
+public class BenchmarkTest02003 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a69278 = param; // assign
+        StringBuilder b69278 = new StringBuilder(a69278); // stick in stringbuilder
+        b69278.append(" SafeStuff"); // append some safe content
+        b69278.replace(
+                b69278.length() - "Chars".length(),
+                b69278.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map69278 = new java.util.HashMap<String, Object>();
+        map69278.put("key69278", b69278.toString()); // put in a collection
+        String c69278 = (String) map69278.get("key69278"); // get it back out
+        String d69278 = c69278.substring(0, c69278.length() - 1); // extract most of it
+        String e69278 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d69278.getBytes()))); // B64 encode and decode it
+        String f69278 = e69278.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g69278 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g69278); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02004.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02004.java
new file mode 100644
index 0000000000000000000000000000000000000000..c85001858d7a73a305faa8902d492dff10fd7ac1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02004.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02004")
+public class BenchmarkTest02004 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02005.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02005.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc4f5adfbb1367f0d20d43cf8a70d5cd16ec959f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02005.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02005")
+public class BenchmarkTest02005 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map44210 = new java.util.HashMap<String, Object>();
+        map44210.put("keyA-44210", "a-Value"); // put some stuff in the collection
+        map44210.put("keyB-44210", param); // put it in a collection
+        map44210.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map44210.get("keyB-44210"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02006.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02006.java
new file mode 100644
index 0000000000000000000000000000000000000000..46920846e931458b02a20d7705f650bcb9d4f227
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02006.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02006")
+public class BenchmarkTest02006 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz44058 = new StringBuilder(param);
+        String bar = sbxyz44058.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02007.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02007.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce1940634b36c900f5100398a4b0b1fcf2b67eca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02007.java	
@@ -0,0 +1,121 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02007")
+public class BenchmarkTest02007 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02008.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02008.java
new file mode 100644
index 0000000000000000000000000000000000000000..218e55c9ba1fc0bc67d6266b49c1a09a623b627a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02008.java	
@@ -0,0 +1,140 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02008")
+public class BenchmarkTest02008 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a97712 = param; // assign
+        StringBuilder b97712 = new StringBuilder(a97712); // stick in stringbuilder
+        b97712.append(" SafeStuff"); // append some safe content
+        b97712.replace(
+                b97712.length() - "Chars".length(),
+                b97712.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map97712 = new java.util.HashMap<String, Object>();
+        map97712.put("key97712", b97712.toString()); // put in a collection
+        String c97712 = (String) map97712.get("key97712"); // get it back out
+        String d97712 = c97712.substring(0, c97712.length() - 1); // extract most of it
+        String e97712 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d97712.getBytes()))); // B64 encode and decode it
+        String f97712 = e97712.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g97712 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g97712); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02009.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02009.java
new file mode 100644
index 0000000000000000000000000000000000000000..29ba320fe8cd801e5a37d4f92acd55073e7c19a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02009.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02009")
+public class BenchmarkTest02009 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02010.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02010.java
new file mode 100644
index 0000000000000000000000000000000000000000..f448dbf72ddece3a188f14f989a7d677f749231c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02010.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02010")
+public class BenchmarkTest02010 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02011.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02011.java
new file mode 100644
index 0000000000000000000000000000000000000000..909a1b5bbb644ccbb8974efe4032650aa16d664d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02011.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02011")
+public class BenchmarkTest02011 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz64726 = new StringBuilder(param);
+        String bar = sbxyz64726.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02012.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02012.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc055d38da488ec178377387d4f91ee2bc87e064
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02012.java	
@@ -0,0 +1,137 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02012")
+public class BenchmarkTest02012 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a69185 = param; // assign
+        StringBuilder b69185 = new StringBuilder(a69185); // stick in stringbuilder
+        b69185.append(" SafeStuff"); // append some safe content
+        b69185.replace(
+                b69185.length() - "Chars".length(),
+                b69185.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map69185 = new java.util.HashMap<String, Object>();
+        map69185.put("key69185", b69185.toString()); // put in a collection
+        String c69185 = (String) map69185.get("key69185"); // get it back out
+        String d69185 = c69185.substring(0, c69185.length() - 1); // extract most of it
+        String e69185 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d69185.getBytes()))); // B64 encode and decode it
+        String f69185 = e69185.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g69185 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g69185); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02013.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02013.java
new file mode 100644
index 0000000000000000000000000000000000000000..86fbf39afd28c18ebed13da05a1e53332ba1bcf4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02013.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02013")
+public class BenchmarkTest02013 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02014.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02014.java
new file mode 100644
index 0000000000000000000000000000000000000000..1e8ca4a8bebcd4c106f323c481134e95cc8a80c1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02014.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02014")
+public class BenchmarkTest02014 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map37065 = new java.util.HashMap<String, Object>();
+        map37065.put("keyA-37065", "a-Value"); // put some stuff in the collection
+        map37065.put("keyB-37065", param); // put it in a collection
+        map37065.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map37065.get("keyB-37065"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02015.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02015.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec24aa25a347aff60f7d3558a3f9b1d91b048afa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02015.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02015")
+public class BenchmarkTest02015 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02016.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02016.java
new file mode 100644
index 0000000000000000000000000000000000000000..36df05893680d3b26d10a26414ce65155e9caa21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02016.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02016")
+public class BenchmarkTest02016 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> names = request.getHeaderNames();
+        while (names.hasMoreElements()) {
+            String name = (String) names.nextElement();
+
+            if (org.owasp.benchmark.helpers.Utils.commonHeaders.contains(name)) {
+                continue; // If standard header, move on to next one
+            }
+
+            java.util.Enumeration<String> values = request.getHeaders(name);
+            if (values != null && values.hasMoreElements()) {
+                param = name; // Grabs the name of the first non-standard header as the parameter
+                // value
+                break;
+            }
+        }
+        // Note: We don't URL decode header names because people don't normally do that
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02017.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02017.java
new file mode 100644
index 0000000000000000000000000000000000000000..028bd7a33f5477da1cf6aa486bca75231889210c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02017.java	
@@ -0,0 +1,152 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02017")
+public class BenchmarkTest02017 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02017");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02018.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02018.java
new file mode 100644
index 0000000000000000000000000000000000000000..0efe1c36de830ef5329e660a561304e2f9a74b41
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02018.java	
@@ -0,0 +1,165 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02018")
+public class BenchmarkTest02018 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02018");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a50268 = param; // assign
+        StringBuilder b50268 = new StringBuilder(a50268); // stick in stringbuilder
+        b50268.append(" SafeStuff"); // append some safe content
+        b50268.replace(
+                b50268.length() - "Chars".length(),
+                b50268.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map50268 = new java.util.HashMap<String, Object>();
+        map50268.put("key50268", b50268.toString()); // put in a collection
+        String c50268 = (String) map50268.get("key50268"); // get it back out
+        String d50268 = c50268.substring(0, c50268.length() - 1); // extract most of it
+        String e50268 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d50268.getBytes()))); // B64 encode and decode it
+        String f50268 = e50268.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f50268); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02019.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02019.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef23f92bf19e0c9e2c5d72fcde61b41169cbef34
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02019.java	
@@ -0,0 +1,148 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02019")
+public class BenchmarkTest02019 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02019");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02020.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02020.java
new file mode 100644
index 0000000000000000000000000000000000000000..68feef0a40950b6db011dde97973b878b977d08a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02020.java	
@@ -0,0 +1,155 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02020")
+public class BenchmarkTest02020 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02020");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map95233 = new java.util.HashMap<String, Object>();
+        map95233.put("keyA-95233", "a_Value"); // put some stuff in the collection
+        map95233.put("keyB-95233", param); // put it in a collection
+        map95233.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map95233.get("keyB-95233"); // get it back out
+        bar = (String) map95233.get("keyA-95233"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02021.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02021.java
new file mode 100644
index 0000000000000000000000000000000000000000..e029e9bc3e0638d29a4984a707e0cab63a3e5873
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02021.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02021")
+public class BenchmarkTest02021 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02021");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02022.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02022.java
new file mode 100644
index 0000000000000000000000000000000000000000..d872beb07f2e5b1357396da49409fdfff567c602
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02022.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02022")
+public class BenchmarkTest02022 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02022");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02023.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02023.java
new file mode 100644
index 0000000000000000000000000000000000000000..c251556f8d7e848604e30a23fa533dba8cdeb0bc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02023.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02023")
+public class BenchmarkTest02023 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02023");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02024.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02024.java
new file mode 100644
index 0000000000000000000000000000000000000000..bcaf065d743c031d9c997816ba22062872c77798
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02024.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02024")
+public class BenchmarkTest02024 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02024");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02025.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02025.java
new file mode 100644
index 0000000000000000000000000000000000000000..e0c2cbc86c506aff24692e63275dc98a3dc9c690
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02025.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02025")
+public class BenchmarkTest02025 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02025");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02026.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02026.java
new file mode 100644
index 0000000000000000000000000000000000000000..60f3255adb84f85ab9717d8176b2b545eae22f00
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02026.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02026")
+public class BenchmarkTest02026 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02026");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02027.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02027.java
new file mode 100644
index 0000000000000000000000000000000000000000..f8a87240ca98a042a70501c4e7df9c947444956b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02027.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02027")
+public class BenchmarkTest02027 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02027");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02028.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02028.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec2779af12b8ef43da2df7a9f3052f43a2c09d59
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02028.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02028")
+public class BenchmarkTest02028 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02028");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02029.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02029.java
new file mode 100644
index 0000000000000000000000000000000000000000..50a185000c103694c7ec813c10ad3540abcf99f7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02029.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02029")
+public class BenchmarkTest02029 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02029");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map96688 = new java.util.HashMap<String, Object>();
+        map96688.put("keyA-96688", "a_Value"); // put some stuff in the collection
+        map96688.put("keyB-96688", param); // put it in a collection
+        map96688.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map96688.get("keyB-96688"); // get it back out
+        bar = (String) map96688.get("keyA-96688"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02030.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02030.java
new file mode 100644
index 0000000000000000000000000000000000000000..b653bfdca1c3670ddbfe58889102ea7effa787c9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02030.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02030")
+public class BenchmarkTest02030 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02030");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a60868 = param; // assign
+        StringBuilder b60868 = new StringBuilder(a60868); // stick in stringbuilder
+        b60868.append(" SafeStuff"); // append some safe content
+        b60868.replace(
+                b60868.length() - "Chars".length(),
+                b60868.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map60868 = new java.util.HashMap<String, Object>();
+        map60868.put("key60868", b60868.toString()); // put in a collection
+        String c60868 = (String) map60868.get("key60868"); // get it back out
+        String d60868 = c60868.substring(0, c60868.length() - 1); // extract most of it
+        String e60868 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d60868.getBytes()))); // B64 encode and decode it
+        String f60868 = e60868.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g60868 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g60868); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02031.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02031.java
new file mode 100644
index 0000000000000000000000000000000000000000..0886d43492bcc6d5a3adee729f9a194143e78bdc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02031.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02031")
+public class BenchmarkTest02031 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02031");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02032.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02032.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e32955f213988c304dc7f10703edd2d56972f64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02032.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02032")
+public class BenchmarkTest02032 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02032");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02033.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02033.java
new file mode 100644
index 0000000000000000000000000000000000000000..db7cbfb7def740f1cd07b277fcb0fcc200b7c60e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02033.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02033")
+public class BenchmarkTest02033 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02033");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02034.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02034.java
new file mode 100644
index 0000000000000000000000000000000000000000..a8786abbc014a19c41be49f49984eb0a387fd640
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02034.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02034")
+public class BenchmarkTest02034 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02034");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02035.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02035.java
new file mode 100644
index 0000000000000000000000000000000000000000..14a47bfb756d1eab4439e9032b713abd11c785ca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02035.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02035")
+public class BenchmarkTest02035 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02035");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02036.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02036.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d91884667a70e57de3165418932ccb099728821
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02036.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02036")
+public class BenchmarkTest02036 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02036");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02037.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02037.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f32cde7eeadbbce4436a434ee10aab626424b9d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02037.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02037")
+public class BenchmarkTest02037 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02037");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02038.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02038.java
new file mode 100644
index 0000000000000000000000000000000000000000..172af27e8499c2151ba78f8d6ce7fd5b2dc1bd17
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02038.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02038")
+public class BenchmarkTest02038 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02038");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02039.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02039.java
new file mode 100644
index 0000000000000000000000000000000000000000..5372a09136d2f06d7c241a80f8ab493bdfb12223
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02039.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02039")
+public class BenchmarkTest02039 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02039");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02040.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02040.java
new file mode 100644
index 0000000000000000000000000000000000000000..75976cdd7d6b14704d3d1c8de1b1abc5f9c05f7d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02040.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02040")
+public class BenchmarkTest02040 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02040");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02041.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02041.java
new file mode 100644
index 0000000000000000000000000000000000000000..1861d198b8063485867e04c7a2e8bfb53296c1f5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02041.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02041")
+public class BenchmarkTest02041 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02041");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02042.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02042.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2444970cf3cfd7fdf96dcc15ed0904a6392ec88
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02042.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02042")
+public class BenchmarkTest02042 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02042");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02043.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02043.java
new file mode 100644
index 0000000000000000000000000000000000000000..c137a030c115f02c5b4855a09c4b358df7bd51a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02043.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02043")
+public class BenchmarkTest02043 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02043");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map52182 = new java.util.HashMap<String, Object>();
+        map52182.put("keyA-52182", "a_Value"); // put some stuff in the collection
+        map52182.put("keyB-52182", param); // put it in a collection
+        map52182.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map52182.get("keyB-52182"); // get it back out
+        bar = (String) map52182.get("keyA-52182"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02044.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02044.java
new file mode 100644
index 0000000000000000000000000000000000000000..97cbcabb7da7a3b531726473a94af78e50b5d9cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02044.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02044")
+public class BenchmarkTest02044 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02044");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz15026 = new StringBuilder(param);
+        String bar = sbxyz15026.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02045.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02045.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae29be160befc33e81061d4039a66c13664179f5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02045.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02045")
+public class BenchmarkTest02045 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02046.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02046.java
new file mode 100644
index 0000000000000000000000000000000000000000..de612ced163c1ff845d40b053ba4641a47f699fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02046.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02046")
+public class BenchmarkTest02046 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map81510 = new java.util.HashMap<String, Object>();
+        map81510.put("keyA-81510", "a-Value"); // put some stuff in the collection
+        map81510.put("keyB-81510", param); // put it in a collection
+        map81510.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map81510.get("keyB-81510"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02047.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02047.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd94629262859fb3aa14601bdefc763da1cd969d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02047.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02047")
+public class BenchmarkTest02047 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02048.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02048.java
new file mode 100644
index 0000000000000000000000000000000000000000..1c47b5009b6934961cbfaecc5b38cd31c9d165d5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02048.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02048")
+public class BenchmarkTest02048 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a96053 = param; // assign
+        StringBuilder b96053 = new StringBuilder(a96053); // stick in stringbuilder
+        b96053.append(" SafeStuff"); // append some safe content
+        b96053.replace(
+                b96053.length() - "Chars".length(),
+                b96053.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map96053 = new java.util.HashMap<String, Object>();
+        map96053.put("key96053", b96053.toString()); // put in a collection
+        String c96053 = (String) map96053.get("key96053"); // get it back out
+        String d96053 = c96053.substring(0, c96053.length() - 1); // extract most of it
+        String e96053 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d96053.getBytes()))); // B64 encode and decode it
+        String f96053 = e96053.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g96053 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g96053); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02049.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02049.java
new file mode 100644
index 0000000000000000000000000000000000000000..7bc57dff4bcb53fd58b7b8cc2d037f9599b89c94
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02049.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02049")
+public class BenchmarkTest02049 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02050.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02050.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7a038b14a4f2e6307c449b69f95814552a79644
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02050.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02050")
+public class BenchmarkTest02050 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02051.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02051.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5d64542e44292d43f51f68495b1b70d2397efcb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02051.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02051")
+public class BenchmarkTest02051 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02052.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02052.java
new file mode 100644
index 0000000000000000000000000000000000000000..47da04c103bd4042497122b99ebe8778612a8e82
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02052.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02052")
+public class BenchmarkTest02052 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map20081 = new java.util.HashMap<String, Object>();
+        map20081.put("keyA-20081", "a_Value"); // put some stuff in the collection
+        map20081.put("keyB-20081", param); // put it in a collection
+        map20081.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map20081.get("keyB-20081"); // get it back out
+        bar = (String) map20081.get("keyA-20081"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02053.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02053.java
new file mode 100644
index 0000000000000000000000000000000000000000..9037405139ef482c25dc0f67a0939e7730aa98f7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02053.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02053")
+public class BenchmarkTest02053 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02054.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02054.java
new file mode 100644
index 0000000000000000000000000000000000000000..4467116539bfbb6405b13f3cc0cd3c59fc2d611a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02054.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02054")
+public class BenchmarkTest02054 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02055.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02055.java
new file mode 100644
index 0000000000000000000000000000000000000000..144c6669d1e118659cac64bd259ebcaec8b4b533
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02055.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02055")
+public class BenchmarkTest02055 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02056.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02056.java
new file mode 100644
index 0000000000000000000000000000000000000000..329c36ec1fffda9e06dbf9e7df3126f9f7b55394
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02056.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02056")
+public class BenchmarkTest02056 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map88820 = new java.util.HashMap<String, Object>();
+        map88820.put("keyA-88820", "a-Value"); // put some stuff in the collection
+        map88820.put("keyB-88820", param); // put it in a collection
+        map88820.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map88820.get("keyB-88820"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02057.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02057.java
new file mode 100644
index 0000000000000000000000000000000000000000..e12cea1c347e9eff84753d73bc722ab3cb566bbc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02057.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02057")
+public class BenchmarkTest02057 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("Referer");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02058.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02058.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a5a16112d55726c7638ba6a73306f8b97f7dfa9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02058.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02058")
+public class BenchmarkTest02058 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02058");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02059.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02059.java
new file mode 100644
index 0000000000000000000000000000000000000000..a61b1191670af87e2605c213454795483e39276a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02059.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02059")
+public class BenchmarkTest02059 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02059");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map36421 = new java.util.HashMap<String, Object>();
+        map36421.put("keyA-36421", "a-Value"); // put some stuff in the collection
+        map36421.put("keyB-36421", param); // put it in a collection
+        map36421.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map36421.get("keyB-36421"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02060.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02060.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f0394409dd86a93f785febc39185eed533705ae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02060.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02060")
+public class BenchmarkTest02060 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02060");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02061.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02061.java
new file mode 100644
index 0000000000000000000000000000000000000000..28d4b373cb49785a6067a72bd10a38b028ed7c0a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02061.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02061")
+public class BenchmarkTest02061 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02061");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02062.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02062.java
new file mode 100644
index 0000000000000000000000000000000000000000..e419ad82369267b400c67ccc252e42ec2cc37c5c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02062.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02062")
+public class BenchmarkTest02062 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02062");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a60435 = param; // assign
+        StringBuilder b60435 = new StringBuilder(a60435); // stick in stringbuilder
+        b60435.append(" SafeStuff"); // append some safe content
+        b60435.replace(
+                b60435.length() - "Chars".length(),
+                b60435.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map60435 = new java.util.HashMap<String, Object>();
+        map60435.put("key60435", b60435.toString()); // put in a collection
+        String c60435 = (String) map60435.get("key60435"); // get it back out
+        String d60435 = c60435.substring(0, c60435.length() - 1); // extract most of it
+        String e60435 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d60435.getBytes()))); // B64 encode and decode it
+        String f60435 = e60435.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g60435 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g60435); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02063.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02063.java
new file mode 100644
index 0000000000000000000000000000000000000000..44098ee93a662bdb662147acda9d2a1aa5e32898
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02063.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02063")
+public class BenchmarkTest02063 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02063");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02064.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02064.java
new file mode 100644
index 0000000000000000000000000000000000000000..07912d6acbe1df7be3b3f29a128434fe7a890122
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02064.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02064")
+public class BenchmarkTest02064 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02064");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map96496 = new java.util.HashMap<String, Object>();
+        map96496.put("keyA-96496", "a_Value"); // put some stuff in the collection
+        map96496.put("keyB-96496", param); // put it in a collection
+        map96496.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map96496.get("keyB-96496"); // get it back out
+        bar = (String) map96496.get("keyA-96496"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02065.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02065.java
new file mode 100644
index 0000000000000000000000000000000000000000..b91f908ab3bf96f467fe5b259b284970ee8d9878
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02065.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02065")
+public class BenchmarkTest02065 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02065");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02066.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02066.java
new file mode 100644
index 0000000000000000000000000000000000000000..1007313533078da4d891880eeea9e195474e86d9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02066.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02066")
+public class BenchmarkTest02066 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02066");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02067.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02067.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a8ef6ad1033660cc7988ecaa51435ed1d89b874
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02067.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02067")
+public class BenchmarkTest02067 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02067");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02068.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02068.java
new file mode 100644
index 0000000000000000000000000000000000000000..27698afcad3da95c0a72052c0ce4d8b908a892a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02068.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02068")
+public class BenchmarkTest02068 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02068");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02069.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02069.java
new file mode 100644
index 0000000000000000000000000000000000000000..21ee7acfa72760f58a6e678902a0a823a7b84391
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02069.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02069")
+public class BenchmarkTest02069 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02069");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02070.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02070.java
new file mode 100644
index 0000000000000000000000000000000000000000..f4570985a9cf9e06628d953c29458e7782b3bf4c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02070.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02070")
+public class BenchmarkTest02070 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02070");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02071.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02071.java
new file mode 100644
index 0000000000000000000000000000000000000000..f62ce3568684e50090f7ef85fbdc57e3da0655fd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02071.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02071")
+public class BenchmarkTest02071 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02071");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map68280 = new java.util.HashMap<String, Object>();
+        map68280.put("keyA-68280", "a-Value"); // put some stuff in the collection
+        map68280.put("keyB-68280", param); // put it in a collection
+        map68280.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map68280.get("keyB-68280"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02072.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02072.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6612e9c3e9278a82fb2528b31f4e49df97aff74
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02072.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02072")
+public class BenchmarkTest02072 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02072");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02073.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02073.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a740d36c2b581163cfcdd521b0f628451fa4fc6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02073.java	
@@ -0,0 +1,130 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02073")
+public class BenchmarkTest02073 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02073");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02074.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02074.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc58f9629881e37d7ce0a1589c4d64006dc6a748
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02074.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02074")
+public class BenchmarkTest02074 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02074");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz8662 = new StringBuilder(param);
+        String bar = sbxyz8662.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02075.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02075.java
new file mode 100644
index 0000000000000000000000000000000000000000..6eedda8d2b879f61cf4a3705beb08b2d7ee120f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02075.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02075")
+public class BenchmarkTest02075 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02075");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02076.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02076.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f3827acd2fa77bc6db38092f8d9018d10d984e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02076.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02076")
+public class BenchmarkTest02076 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02076");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map15760 = new java.util.HashMap<String, Object>();
+        map15760.put("keyA-15760", "a-Value"); // put some stuff in the collection
+        map15760.put("keyB-15760", param); // put it in a collection
+        map15760.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map15760.get("keyB-15760"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02077.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02077.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e44a8f1b6c5eb398867f8a3e32d6121bc92c44a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02077.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02077")
+public class BenchmarkTest02077 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02077");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a78258 = param; // assign
+        StringBuilder b78258 = new StringBuilder(a78258); // stick in stringbuilder
+        b78258.append(" SafeStuff"); // append some safe content
+        b78258.replace(
+                b78258.length() - "Chars".length(),
+                b78258.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map78258 = new java.util.HashMap<String, Object>();
+        map78258.put("key78258", b78258.toString()); // put in a collection
+        String c78258 = (String) map78258.get("key78258"); // get it back out
+        String d78258 = c78258.substring(0, c78258.length() - 1); // extract most of it
+        String e78258 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d78258.getBytes()))); // B64 encode and decode it
+        String f78258 = e78258.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g78258 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g78258); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02078.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02078.java
new file mode 100644
index 0000000000000000000000000000000000000000..09a409da0282b39d5d74a3bee12ef8a247ee0ee6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02078.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02078")
+public class BenchmarkTest02078 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02078");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02079.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02079.java
new file mode 100644
index 0000000000000000000000000000000000000000..46e0182e46896230a4c4e89f4a2f46d6f01c3d45
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02079.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02079")
+public class BenchmarkTest02079 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02079");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02080.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02080.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a6dc196b5b14228bce4992ec729091e392bc2aa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02080.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02080")
+public class BenchmarkTest02080 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02080");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02081.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02081.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6fbf59764993ef6849ded173bbae965b4642121
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02081.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02081")
+public class BenchmarkTest02081 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02081");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a44156 = param; // assign
+        StringBuilder b44156 = new StringBuilder(a44156); // stick in stringbuilder
+        b44156.append(" SafeStuff"); // append some safe content
+        b44156.replace(
+                b44156.length() - "Chars".length(),
+                b44156.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map44156 = new java.util.HashMap<String, Object>();
+        map44156.put("key44156", b44156.toString()); // put in a collection
+        String c44156 = (String) map44156.get("key44156"); // get it back out
+        String d44156 = c44156.substring(0, c44156.length() - 1); // extract most of it
+        String e44156 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d44156.getBytes()))); // B64 encode and decode it
+        String f44156 = e44156.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f44156); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02082.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02082.java
new file mode 100644
index 0000000000000000000000000000000000000000..628c19348353d7dc970a09fd56cddb9446c8d330
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02082.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02082")
+public class BenchmarkTest02082 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02082");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02083.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02083.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec2aedc91313677fb169cf79036b5eb2d975eb5c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02083.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02083")
+public class BenchmarkTest02083 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02083");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02084.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02084.java
new file mode 100644
index 0000000000000000000000000000000000000000..ffe22cac788b4e0c232a1853a0478c0dac5eebb0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02084.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02084")
+public class BenchmarkTest02084 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02084");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02085.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02085.java
new file mode 100644
index 0000000000000000000000000000000000000000..684035f538a343ec6daea083b745914025722b24
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02085.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02085")
+public class BenchmarkTest02085 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02085");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02086.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02086.java
new file mode 100644
index 0000000000000000000000000000000000000000..dfbac82f663dfe279676c5bdeee62cde9818c55e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02086.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02086")
+public class BenchmarkTest02086 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02086");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02087.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02087.java
new file mode 100644
index 0000000000000000000000000000000000000000..c96794c8c2b3710a807a0a7b3211870e66334a5a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02087.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02087")
+public class BenchmarkTest02087 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02087");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02088.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02088.java
new file mode 100644
index 0000000000000000000000000000000000000000..141014a0a4a4311dfa1bfe795cff49ad2e23a5df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02088.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02088")
+public class BenchmarkTest02088 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02088");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02089.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02089.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5d806fed516b598d972c4e4c58abc1abc8b0b00
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02089.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02089")
+public class BenchmarkTest02089 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02089");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02090.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02090.java
new file mode 100644
index 0000000000000000000000000000000000000000..14305c3208b861fea58ab1fc3677511c88a74bfb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02090.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02090")
+public class BenchmarkTest02090 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02090");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02091.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02091.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5b2593a4faca31fc968aff6b21bebc142e7e4d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02091.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02091")
+public class BenchmarkTest02091 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02091");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02092.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02092.java
new file mode 100644
index 0000000000000000000000000000000000000000..00fb0d35045cc0a83a812e7f429b75d7f5040fa6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02092.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02092")
+public class BenchmarkTest02092 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02092");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02093.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02093.java
new file mode 100644
index 0000000000000000000000000000000000000000..62abe5cea8bce6405a09735248df1c43c68eb710
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02093.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02093")
+public class BenchmarkTest02093 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02093");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02094.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02094.java
new file mode 100644
index 0000000000000000000000000000000000000000..1cd616a724d92063d76625ff41c687c5d1869104
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02094.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02094")
+public class BenchmarkTest02094 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02094");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02095.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02095.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6dbe338f3b4bcb28eed823a0467ba2a45b6d3a6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02095.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02095")
+public class BenchmarkTest02095 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02095");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map43923 = new java.util.HashMap<String, Object>();
+        map43923.put("keyA-43923", "a_Value"); // put some stuff in the collection
+        map43923.put("keyB-43923", param); // put it in a collection
+        map43923.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map43923.get("keyB-43923"); // get it back out
+        bar = (String) map43923.get("keyA-43923"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02096.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02096.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7e83158cfc846a692e74d4b8317540bbf54ac80
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02096.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02096")
+public class BenchmarkTest02096 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02096");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02097.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02097.java
new file mode 100644
index 0000000000000000000000000000000000000000..dde16dc7b6b4890b6fde336dc0c495192e9adaa3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02097.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02097")
+public class BenchmarkTest02097 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02097");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map94015 = new java.util.HashMap<String, Object>();
+        map94015.put("keyA-94015", "a_Value"); // put some stuff in the collection
+        map94015.put("keyB-94015", param); // put it in a collection
+        map94015.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map94015.get("keyB-94015"); // get it back out
+        bar = (String) map94015.get("keyA-94015"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02098.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02098.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa7abf60830c07488e823d3da6da0bb45011e848
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02098.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02098")
+public class BenchmarkTest02098 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02098");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02099.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02099.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b9508e2882df7d8bc81f9f420578702eaa9b672
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02099.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02099")
+public class BenchmarkTest02099 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02099");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02100.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02100.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba5e1b7b22589d174b43e6c255243593c98f3ef7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02100.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest02100")
+public class BenchmarkTest02100 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        java.util.Enumeration<String> headers = request.getHeaders("BenchmarkTest02100");
+
+        if (headers != null && headers.hasMoreElements()) {
+            param = headers.nextElement(); // just grab first element
+        }
+
+        // URL Decode the header value since req.getHeaders() doesn't. Unlike req.getParameters().
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02101.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02101.java
new file mode 100644
index 0000000000000000000000000000000000000000..26fac96c606803e6de189435f7d280e33ddbfe70
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02101.java	
@@ -0,0 +1,145 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02101")
+public class BenchmarkTest02101 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02101");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02102.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02102.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c884527bef5560d93074a07c83ba4edc3ebf25c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02102.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02102")
+public class BenchmarkTest02102 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02102");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz85369 = new StringBuilder(param);
+            bar = sbxyz85369.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02103.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02103.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7dd1c6532e1d1478717a06a7256e4d8c610974a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02103.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02103")
+public class BenchmarkTest02103 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02103");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02104.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02104.java
new file mode 100644
index 0000000000000000000000000000000000000000..476396ab90f5b7a8e18d50e72444289b97308ff3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02104.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02104")
+public class BenchmarkTest02104 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02104");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02105.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02105.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2eb1b4c549fdcc4cd8a4866dfd74c039f7add6b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02105.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02105")
+public class BenchmarkTest02105 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02105");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02106.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02106.java
new file mode 100644
index 0000000000000000000000000000000000000000..62179800273e1f115208c0f8f65c468a67755510
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02106.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02106")
+public class BenchmarkTest02106 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02106");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02107.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02107.java
new file mode 100644
index 0000000000000000000000000000000000000000..674e2a0419db942865adf6bf1c6b9ff44dd362c9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02107.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02107")
+public class BenchmarkTest02107 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02107");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02108.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02108.java
new file mode 100644
index 0000000000000000000000000000000000000000..134a0bb17159497fbeb342743b658524b9a05a99
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02108.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02108")
+public class BenchmarkTest02108 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02108");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map44255 = new java.util.HashMap<String, Object>();
+        map44255.put("keyA-44255", "a_Value"); // put some stuff in the collection
+        map44255.put("keyB-44255", param); // put it in a collection
+        map44255.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map44255.get("keyB-44255"); // get it back out
+        bar = (String) map44255.get("keyA-44255"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02109.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02109.java
new file mode 100644
index 0000000000000000000000000000000000000000..ef872b250e0cfb09e8b56fa6049f650475ee1844
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02109.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02109")
+public class BenchmarkTest02109 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02109");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02110.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02110.java
new file mode 100644
index 0000000000000000000000000000000000000000..b69c9e6fa6612bacd3b331e6ddd2903a33ed2edf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02110.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02110")
+public class BenchmarkTest02110 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02110");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02111.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02111.java
new file mode 100644
index 0000000000000000000000000000000000000000..dfe1cbd371492dc545b2bda04a892ec9b94477a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02111.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02111")
+public class BenchmarkTest02111 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02111");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02112.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02112.java
new file mode 100644
index 0000000000000000000000000000000000000000..b77662a19a925b668b77da59506f9f3cbd2b1ccf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02112.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02112")
+public class BenchmarkTest02112 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02112");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02113.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02113.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b384b7028dce9beb94e8cbc4e0d30bf7d3e8ac9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02113.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02113")
+public class BenchmarkTest02113 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02113");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02114.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02114.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9e66ada163c870a44a93adfa1f80851d787b801
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02114.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02114")
+public class BenchmarkTest02114 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02114");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02115.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02115.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d82b8fe9b5022fba2662938d4250980cde80af8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02115.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02115")
+public class BenchmarkTest02115 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02115");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map89109 = new java.util.HashMap<String, Object>();
+        map89109.put("keyA-89109", "a_Value"); // put some stuff in the collection
+        map89109.put("keyB-89109", param); // put it in a collection
+        map89109.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map89109.get("keyB-89109"); // get it back out
+        bar = (String) map89109.get("keyA-89109"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02116.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02116.java
new file mode 100644
index 0000000000000000000000000000000000000000..6df78da490c893e702e045ec37e0ee4837c81e38
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02116.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02116")
+public class BenchmarkTest02116 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02116");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02117.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02117.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ac7f7b8c4e2dd5e4d9fa1e8e403e83a531faf73
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02117.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02117")
+public class BenchmarkTest02117 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02117");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map12987 = new java.util.HashMap<String, Object>();
+        map12987.put("keyA-12987", "a-Value"); // put some stuff in the collection
+        map12987.put("keyB-12987", param); // put it in a collection
+        map12987.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map12987.get("keyB-12987"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02118.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02118.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f454b1b02bc23863545abc3bf2b9e9167a9d8a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02118.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02118")
+public class BenchmarkTest02118 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02118");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02119.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02119.java
new file mode 100644
index 0000000000000000000000000000000000000000..4540f8960e7ba305c4a66dc64408c37a873fe549
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02119.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02119")
+public class BenchmarkTest02119 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02119");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map70096 = new java.util.HashMap<String, Object>();
+        map70096.put("keyA-70096", "a-Value"); // put some stuff in the collection
+        map70096.put("keyB-70096", param); // put it in a collection
+        map70096.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map70096.get("keyB-70096"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02120.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02120.java
new file mode 100644
index 0000000000000000000000000000000000000000..c712ba45d1714c33e164d6cc64e34ff093888ab0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02120.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02120")
+public class BenchmarkTest02120 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02120");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02121.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02121.java
new file mode 100644
index 0000000000000000000000000000000000000000..e20400f2480b57ec6886275191c210d2a6f4fa64
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02121.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02121")
+public class BenchmarkTest02121 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02121");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02122.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02122.java
new file mode 100644
index 0000000000000000000000000000000000000000..9df97fe3fa9a78a81fcef1a3df3c9478daeead45
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02122.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-03/BenchmarkTest02122")
+public class BenchmarkTest02122 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02122");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02123.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02123.java
new file mode 100644
index 0000000000000000000000000000000000000000..a415757a881de758a43163c664bd80ee6c5a51b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02123.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02123")
+public class BenchmarkTest02123 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02123");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02124.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02124.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d06514976a1cdbea95e4334d81eec9466f30a94
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02124.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02124")
+public class BenchmarkTest02124 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02124");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz69250 = new StringBuilder(param);
+            bar = sbxyz69250.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02125.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02125.java
new file mode 100644
index 0000000000000000000000000000000000000000..30373fb0c0f5679072268e75e12f7efe78804f27
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02125.java	
@@ -0,0 +1,41 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02125")
+public class BenchmarkTest02125 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02125");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02126.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02126.java
new file mode 100644
index 0000000000000000000000000000000000000000..70f4d683f858c663c0e7070ff2e0351b8f4b0e8e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02126.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02126")
+public class BenchmarkTest02126 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02126");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a64181 = param; // assign
+        StringBuilder b64181 = new StringBuilder(a64181); // stick in stringbuilder
+        b64181.append(" SafeStuff"); // append some safe content
+        b64181.replace(
+                b64181.length() - "Chars".length(),
+                b64181.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map64181 = new java.util.HashMap<String, Object>();
+        map64181.put("key64181", b64181.toString()); // put in a collection
+        String c64181 = (String) map64181.get("key64181"); // get it back out
+        String d64181 = c64181.substring(0, c64181.length() - 1); // extract most of it
+        String e64181 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d64181.getBytes()))); // B64 encode and decode it
+        String f64181 = e64181.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f64181); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02127.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02127.java
new file mode 100644
index 0000000000000000000000000000000000000000..31b3bd45b2dfdbb72c775ec02828168d795183ba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02127.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02127")
+public class BenchmarkTest02127 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02127");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02128.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02128.java
new file mode 100644
index 0000000000000000000000000000000000000000..9da0f6b010e9e7bd8ec3dd3b129d78696aaf5477
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02128.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02128")
+public class BenchmarkTest02128 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02128");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02129.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02129.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9bd2db50b223d3607f8bcd00dc6c6ff94b38b08
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02129.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02129")
+public class BenchmarkTest02129 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02129");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02130.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02130.java
new file mode 100644
index 0000000000000000000000000000000000000000..c92aeebcf7724b82ecb59dc7ede1b64b9fe954bd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02130.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02130")
+public class BenchmarkTest02130 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02130");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz60224 = new StringBuilder(param);
+        String bar = sbxyz60224.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02131.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02131.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a9de1ed0f25a99290bc469281b11f9a0375cf99
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02131.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02131")
+public class BenchmarkTest02131 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02131");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02132.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02132.java
new file mode 100644
index 0000000000000000000000000000000000000000..b910bcca96e6e6abd0079fdf4210d3e728eb8ae8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02132.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02132")
+public class BenchmarkTest02132 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02132");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a76744 = param; // assign
+        StringBuilder b76744 = new StringBuilder(a76744); // stick in stringbuilder
+        b76744.append(" SafeStuff"); // append some safe content
+        b76744.replace(
+                b76744.length() - "Chars".length(),
+                b76744.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map76744 = new java.util.HashMap<String, Object>();
+        map76744.put("key76744", b76744.toString()); // put in a collection
+        String c76744 = (String) map76744.get("key76744"); // get it back out
+        String d76744 = c76744.substring(0, c76744.length() - 1); // extract most of it
+        String e76744 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d76744.getBytes()))); // B64 encode and decode it
+        String f76744 = e76744.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f76744); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02133.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02133.java
new file mode 100644
index 0000000000000000000000000000000000000000..086bcf57a365c617cae9c4c8b8bce2cd8841a42a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02133.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02133")
+public class BenchmarkTest02133 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02133");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02134.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02134.java
new file mode 100644
index 0000000000000000000000000000000000000000..2be0a9f8bca2dfad475e820188ac8afb7c85f587
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02134.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02134")
+public class BenchmarkTest02134 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02134");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02135.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02135.java
new file mode 100644
index 0000000000000000000000000000000000000000..e37a8960429dc39aafe85de47ad72b39296dec88
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02135.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02135")
+public class BenchmarkTest02135 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02135");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a95930 = param; // assign
+        StringBuilder b95930 = new StringBuilder(a95930); // stick in stringbuilder
+        b95930.append(" SafeStuff"); // append some safe content
+        b95930.replace(
+                b95930.length() - "Chars".length(),
+                b95930.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map95930 = new java.util.HashMap<String, Object>();
+        map95930.put("key95930", b95930.toString()); // put in a collection
+        String c95930 = (String) map95930.get("key95930"); // get it back out
+        String d95930 = c95930.substring(0, c95930.length() - 1); // extract most of it
+        String e95930 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d95930.getBytes()))); // B64 encode and decode it
+        String f95930 = e95930.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g95930 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g95930); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02136.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02136.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a0fa50383e05a1fd72219a11beee297a2a7dbd4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02136.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02136")
+public class BenchmarkTest02136 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02136");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02137.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02137.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f1f045f6e384ebcd2a014eb2accace35d1eebd8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02137.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02137")
+public class BenchmarkTest02137 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02137");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02138.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02138.java
new file mode 100644
index 0000000000000000000000000000000000000000..24dd652b2148bdc8cc4c1a15fc55a9e76fc4a0bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02138.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02138")
+public class BenchmarkTest02138 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02138");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02139.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02139.java
new file mode 100644
index 0000000000000000000000000000000000000000..06fb9f211516d2cb56ffbd6985b32e461f4f310b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02139.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02139")
+public class BenchmarkTest02139 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02139");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02140.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02140.java
new file mode 100644
index 0000000000000000000000000000000000000000..268ec99a290b538ad7270baee54121fcce8eb7d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02140.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02140")
+public class BenchmarkTest02140 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02140");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02141.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02141.java
new file mode 100644
index 0000000000000000000000000000000000000000..60129a2a4d84908d35a057bbbac871eb3675955f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02141.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02141")
+public class BenchmarkTest02141 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02141");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02142.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02142.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae50162e28a075afe42e431ddd1874e71cfde660
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02142.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02142")
+public class BenchmarkTest02142 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02142");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02143.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02143.java
new file mode 100644
index 0000000000000000000000000000000000000000..da6536e24d836d25c365e95f4312fea5958720df
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02143.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02143")
+public class BenchmarkTest02143 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02143");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map44285 = new java.util.HashMap<String, Object>();
+        map44285.put("keyA-44285", "a_Value"); // put some stuff in the collection
+        map44285.put("keyB-44285", param); // put it in a collection
+        map44285.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map44285.get("keyB-44285"); // get it back out
+        bar = (String) map44285.get("keyA-44285"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02144.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02144.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b90326dde5556824ed14de22891c960247b2b48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02144.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02144")
+public class BenchmarkTest02144 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02144");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02145.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02145.java
new file mode 100644
index 0000000000000000000000000000000000000000..95af60480be6876abbd2d1120639e189e1aaf890
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02145.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02145")
+public class BenchmarkTest02145 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02145");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a32743 = param; // assign
+        StringBuilder b32743 = new StringBuilder(a32743); // stick in stringbuilder
+        b32743.append(" SafeStuff"); // append some safe content
+        b32743.replace(
+                b32743.length() - "Chars".length(),
+                b32743.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map32743 = new java.util.HashMap<String, Object>();
+        map32743.put("key32743", b32743.toString()); // put in a collection
+        String c32743 = (String) map32743.get("key32743"); // get it back out
+        String d32743 = c32743.substring(0, c32743.length() - 1); // extract most of it
+        String e32743 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d32743.getBytes()))); // B64 encode and decode it
+        String f32743 = e32743.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f32743); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02146.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02146.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8289e070211b93cb62c6687b7bd891916f98405
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02146.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02146")
+public class BenchmarkTest02146 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02146");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02147.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02147.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb86ef75a25be516866b44c5c04cb0287392c2f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02147.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02147")
+public class BenchmarkTest02147 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02147");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02148.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02148.java
new file mode 100644
index 0000000000000000000000000000000000000000..27da610236109ffdb880e3a8993a346ba4887282
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02148.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02148")
+public class BenchmarkTest02148 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02148");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a17988 = param; // assign
+        StringBuilder b17988 = new StringBuilder(a17988); // stick in stringbuilder
+        b17988.append(" SafeStuff"); // append some safe content
+        b17988.replace(
+                b17988.length() - "Chars".length(),
+                b17988.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map17988 = new java.util.HashMap<String, Object>();
+        map17988.put("key17988", b17988.toString()); // put in a collection
+        String c17988 = (String) map17988.get("key17988"); // get it back out
+        String d17988 = c17988.substring(0, c17988.length() - 1); // extract most of it
+        String e17988 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d17988.getBytes()))); // B64 encode and decode it
+        String f17988 = e17988.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g17988 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g17988); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02149.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02149.java
new file mode 100644
index 0000000000000000000000000000000000000000..9474beea65093d1d2e43965a523524cac9f9839d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02149.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02149")
+public class BenchmarkTest02149 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02149");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02150.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02150.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d69a035506181cf6f9898b9cba49bd1630883c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02150.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02150")
+public class BenchmarkTest02150 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02150");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02151.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02151.java
new file mode 100644
index 0000000000000000000000000000000000000000..9fe9893ed7810fdcc1b409065239171f2e75e285
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02151.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02151")
+public class BenchmarkTest02151 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02151");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02152.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02152.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e376c128c5f8722b0074c0045a8c59f2841f011
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02152.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02152")
+public class BenchmarkTest02152 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02152");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02153.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02153.java
new file mode 100644
index 0000000000000000000000000000000000000000..a47092485684a139ae6ff6eeefdeaef3887d6ba5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02153.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02153")
+public class BenchmarkTest02153 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02153");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a82592 = param; // assign
+        StringBuilder b82592 = new StringBuilder(a82592); // stick in stringbuilder
+        b82592.append(" SafeStuff"); // append some safe content
+        b82592.replace(
+                b82592.length() - "Chars".length(),
+                b82592.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map82592 = new java.util.HashMap<String, Object>();
+        map82592.put("key82592", b82592.toString()); // put in a collection
+        String c82592 = (String) map82592.get("key82592"); // get it back out
+        String d82592 = c82592.substring(0, c82592.length() - 1); // extract most of it
+        String e82592 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d82592.getBytes()))); // B64 encode and decode it
+        String f82592 = e82592.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g82592 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g82592); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02154.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02154.java
new file mode 100644
index 0000000000000000000000000000000000000000..253d3991586a36c08db8bf202ea161f64d230b10
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02154.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02154")
+public class BenchmarkTest02154 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02154");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02155.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02155.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0e94c56cea07caa6421db0090eae97f352ab4d7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02155.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02155")
+public class BenchmarkTest02155 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02155");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02156.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02156.java
new file mode 100644
index 0000000000000000000000000000000000000000..567143ef2b3ec3efac810bd8a67658d0a2318b9f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02156.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02156")
+public class BenchmarkTest02156 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02156");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02157.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02157.java
new file mode 100644
index 0000000000000000000000000000000000000000..3efb7cb5d54f1e8b5147a5286025673ccf3a4396
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02157.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02157")
+public class BenchmarkTest02157 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02157");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02158.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02158.java
new file mode 100644
index 0000000000000000000000000000000000000000..d3f3e7752a6a4990b8c069a5e7c320271398cac8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02158.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-04/BenchmarkTest02158")
+public class BenchmarkTest02158 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02158");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02159.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02159.java
new file mode 100644
index 0000000000000000000000000000000000000000..03bf4b99648c81eb4993364e64601f64b8f3f9c0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02159.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02159")
+public class BenchmarkTest02159 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02159");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a66015 = param; // assign
+        StringBuilder b66015 = new StringBuilder(a66015); // stick in stringbuilder
+        b66015.append(" SafeStuff"); // append some safe content
+        b66015.replace(
+                b66015.length() - "Chars".length(),
+                b66015.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map66015 = new java.util.HashMap<String, Object>();
+        map66015.put("key66015", b66015.toString()); // put in a collection
+        String c66015 = (String) map66015.get("key66015"); // get it back out
+        String d66015 = c66015.substring(0, c66015.length() - 1); // extract most of it
+        String e66015 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d66015.getBytes()))); // B64 encode and decode it
+        String f66015 = e66015.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f66015); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02160.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02160.java
new file mode 100644
index 0000000000000000000000000000000000000000..06dccaaef8334257827684757472d79f64b27742
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02160.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02160")
+public class BenchmarkTest02160 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02160");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map25458 = new java.util.HashMap<String, Object>();
+        map25458.put("keyA-25458", "a_Value"); // put some stuff in the collection
+        map25458.put("keyB-25458", param); // put it in a collection
+        map25458.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map25458.get("keyB-25458"); // get it back out
+        bar = (String) map25458.get("keyA-25458"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02161.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02161.java
new file mode 100644
index 0000000000000000000000000000000000000000..b7e9ff27f8c1059efd9f32a2ecf08b589b89138c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02161.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02161")
+public class BenchmarkTest02161 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02161");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02162.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02162.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2e77c5d23ecc8a3a6b2d2de720e7cdb87d01960
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02162.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02162")
+public class BenchmarkTest02162 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02162");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02163.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02163.java
new file mode 100644
index 0000000000000000000000000000000000000000..3452670321bc0d30a0104db4156bea829261e411
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02163.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02163")
+public class BenchmarkTest02163 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02163");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02164.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02164.java
new file mode 100644
index 0000000000000000000000000000000000000000..cbf2120722c1ab09c0c7e9beb800fd87b6461794
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02164.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02164")
+public class BenchmarkTest02164 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02164");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02165.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02165.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7891b560ef2840ca8630b23f5604487e089af53
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02165.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02165")
+public class BenchmarkTest02165 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02165");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02166.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02166.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bb8b67a0b0c669aee1811605211a374aadb84e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02166.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02166")
+public class BenchmarkTest02166 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02166");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02167.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02167.java
new file mode 100644
index 0000000000000000000000000000000000000000..7563ca396344e74d331c6184e567f93213bb35c6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02167.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02167")
+public class BenchmarkTest02167 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02167");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02168.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02168.java
new file mode 100644
index 0000000000000000000000000000000000000000..d7171e0d1df2be0c1ef747317caa0217c3fde42f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02168.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02168")
+public class BenchmarkTest02168 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02168");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02169.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02169.java
new file mode 100644
index 0000000000000000000000000000000000000000..102a9569f738c6d8a223fdd1f2c969afb07526e9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02169.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02169")
+public class BenchmarkTest02169 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02169");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02170.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02170.java
new file mode 100644
index 0000000000000000000000000000000000000000..37f7de17b4daa27adc96c22172ca7b1757860379
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02170.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02170")
+public class BenchmarkTest02170 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02170");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02171.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02171.java
new file mode 100644
index 0000000000000000000000000000000000000000..932b739525823d0b7fe2adebbf6cc707466b9ccb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02171.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02171")
+public class BenchmarkTest02171 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02171");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02172.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02172.java
new file mode 100644
index 0000000000000000000000000000000000000000..130cdb9560c10183d5f3274810937a6308102f8a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02172.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02172")
+public class BenchmarkTest02172 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02172");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02173.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02173.java
new file mode 100644
index 0000000000000000000000000000000000000000..29cb6a074bcb7b4bcd0bce7173e25da67ce02ce8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02173.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02173")
+public class BenchmarkTest02173 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02173");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02174.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02174.java
new file mode 100644
index 0000000000000000000000000000000000000000..0bcc6c3aa5e6122603f35dcb8b366352d939bea9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02174.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02174")
+public class BenchmarkTest02174 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02174");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02175.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02175.java
new file mode 100644
index 0000000000000000000000000000000000000000..eef66549436e634cee85d10046e7e2269143756d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02175.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02175")
+public class BenchmarkTest02175 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02175");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02176.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02176.java
new file mode 100644
index 0000000000000000000000000000000000000000..17626cdf6242d2367697605fe8d923057a6693c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02176.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02176")
+public class BenchmarkTest02176 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02176");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02177.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02177.java
new file mode 100644
index 0000000000000000000000000000000000000000..fba946345301809da5d493efb2e731870456b4b2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02177.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02177")
+public class BenchmarkTest02177 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02177");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02178.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02178.java
new file mode 100644
index 0000000000000000000000000000000000000000..437171d07a37ce103c79e2aa2896f70f7ea8fc69
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02178.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02178")
+public class BenchmarkTest02178 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02178");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map38026 = new java.util.HashMap<String, Object>();
+        map38026.put("keyA-38026", "a-Value"); // put some stuff in the collection
+        map38026.put("keyB-38026", param); // put it in a collection
+        map38026.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map38026.get("keyB-38026"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02179.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02179.java
new file mode 100644
index 0000000000000000000000000000000000000000..3cf529b6467fde2a3c6b72363c6fb21451c0110d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02179.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02179")
+public class BenchmarkTest02179 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02179");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02180.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02180.java
new file mode 100644
index 0000000000000000000000000000000000000000..9222063a50ed7510f5765349dd97a2ae9530bc11
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02180.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02180")
+public class BenchmarkTest02180 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02180");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map32515 = new java.util.HashMap<String, Object>();
+        map32515.put("keyA-32515", "a_Value"); // put some stuff in the collection
+        map32515.put("keyB-32515", param); // put it in a collection
+        map32515.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map32515.get("keyB-32515"); // get it back out
+        bar = (String) map32515.get("keyA-32515"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02181.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02181.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa050a7210667d91dbd50b2849cda998dd8ca2d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02181.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02181")
+public class BenchmarkTest02181 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02181");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02182.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02182.java
new file mode 100644
index 0000000000000000000000000000000000000000..8126062c6ef0d92aa6d5a5ff51b1173121f8caaf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02182.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02182")
+public class BenchmarkTest02182 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02182");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02183.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02183.java
new file mode 100644
index 0000000000000000000000000000000000000000..b387c469d70ceecf091cf363d08f02b5772340d7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02183.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02183")
+public class BenchmarkTest02183 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02183");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a90580 = param; // assign
+        StringBuilder b90580 = new StringBuilder(a90580); // stick in stringbuilder
+        b90580.append(" SafeStuff"); // append some safe content
+        b90580.replace(
+                b90580.length() - "Chars".length(),
+                b90580.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map90580 = new java.util.HashMap<String, Object>();
+        map90580.put("key90580", b90580.toString()); // put in a collection
+        String c90580 = (String) map90580.get("key90580"); // get it back out
+        String d90580 = c90580.substring(0, c90580.length() - 1); // extract most of it
+        String e90580 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d90580.getBytes()))); // B64 encode and decode it
+        String f90580 = e90580.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g90580 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g90580); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02184.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02184.java
new file mode 100644
index 0000000000000000000000000000000000000000..764cde407ba120d1ecfec419a8d1aa83a7c45291
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02184.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02184")
+public class BenchmarkTest02184 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02184");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02185.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02185.java
new file mode 100644
index 0000000000000000000000000000000000000000..0afff4e3c5f71aaad94ff5524719625f7a98f86b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02185.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02185")
+public class BenchmarkTest02185 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02185");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02186.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02186.java
new file mode 100644
index 0000000000000000000000000000000000000000..576d48910774ccb7ac5bec938a1abc75676e5117
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02186.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02186")
+public class BenchmarkTest02186 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02186");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02187.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02187.java
new file mode 100644
index 0000000000000000000000000000000000000000..3df5c870505bc1507d4c0f2d1dacb09bb6789f54
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02187.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02187")
+public class BenchmarkTest02187 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02187");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02188.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02188.java
new file mode 100644
index 0000000000000000000000000000000000000000..72528c9bf661c805c2967d99154c84080cede073
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02188.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02188")
+public class BenchmarkTest02188 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02188");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a16667 = param; // assign
+        StringBuilder b16667 = new StringBuilder(a16667); // stick in stringbuilder
+        b16667.append(" SafeStuff"); // append some safe content
+        b16667.replace(
+                b16667.length() - "Chars".length(),
+                b16667.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map16667 = new java.util.HashMap<String, Object>();
+        map16667.put("key16667", b16667.toString()); // put in a collection
+        String c16667 = (String) map16667.get("key16667"); // get it back out
+        String d16667 = c16667.substring(0, c16667.length() - 1); // extract most of it
+        String e16667 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d16667.getBytes()))); // B64 encode and decode it
+        String f16667 = e16667.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g16667 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g16667); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02189.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02189.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c6819d2015368dd068119b0da520123911192c7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02189.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest02189")
+public class BenchmarkTest02189 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = request.getParameter("BenchmarkTest02189");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02190.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02190.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8e2d4030025e92308bc7ff179e4fb217fba0612
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02190.java	
@@ -0,0 +1,143 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02190")
+public class BenchmarkTest02190 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02190");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02191.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02191.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8e5b87e7b336663738ceb63ccd600fc33a15004
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02191.java	
@@ -0,0 +1,148 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02191")
+public class BenchmarkTest02191 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02191");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02192.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02192.java
new file mode 100644
index 0000000000000000000000000000000000000000..f06afa17f360b9435b0e10279983ab351120139b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02192.java	
@@ -0,0 +1,156 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02192")
+public class BenchmarkTest02192 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02192");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02193.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02193.java
new file mode 100644
index 0000000000000000000000000000000000000000..e523036ca8ef6049106017cd7cf25700a10bac5e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02193.java	
@@ -0,0 +1,165 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02193")
+public class BenchmarkTest02193 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02193");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02194.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02194.java
new file mode 100644
index 0000000000000000000000000000000000000000..92c8f67e8d6cd1bbfa4588f0a2556b09986be6bd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02194.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02194")
+public class BenchmarkTest02194 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02194");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02195.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02195.java
new file mode 100644
index 0000000000000000000000000000000000000000..a36d988f7ef27ac6dc26bcd85cbb136426548bf1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02195.java	
@@ -0,0 +1,117 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02195")
+public class BenchmarkTest02195 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02195");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02196.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02196.java
new file mode 100644
index 0000000000000000000000000000000000000000..2bd6160b48c7a3f5272d93615d78ef8db6a88e03
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02196.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02196")
+public class BenchmarkTest02196 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02196");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02197.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02197.java
new file mode 100644
index 0000000000000000000000000000000000000000..b023b7a52a97e6d0d899c3cce8ca2805e62574ef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02197.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02197")
+public class BenchmarkTest02197 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02197");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map35951 = new java.util.HashMap<String, Object>();
+        map35951.put("keyA-35951", "a-Value"); // put some stuff in the collection
+        map35951.put("keyB-35951", param); // put it in a collection
+        map35951.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map35951.get("keyB-35951"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02198.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02198.java
new file mode 100644
index 0000000000000000000000000000000000000000..0bebf69583c1b1a92dbdd0c5f6b8ad2df28ac29b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02198.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02198")
+public class BenchmarkTest02198 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02198");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02199.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02199.java
new file mode 100644
index 0000000000000000000000000000000000000000..509251a65b8c29391543c0eb42b12ce49408c234
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02199.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02199")
+public class BenchmarkTest02199 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02199");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02200.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02200.java
new file mode 100644
index 0000000000000000000000000000000000000000..e2f107b4a223b4701e7a346fc427d386c7b473aa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02200.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02200")
+public class BenchmarkTest02200 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02200");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02201.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02201.java
new file mode 100644
index 0000000000000000000000000000000000000000..886c3e0e5c363f82ef21ffb003e4354e00cda643
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02201.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02201")
+public class BenchmarkTest02201 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02201");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02202.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02202.java
new file mode 100644
index 0000000000000000000000000000000000000000..5839fe8397ae2a412c3f8e5b3142480c40ff53bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02202.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02202")
+public class BenchmarkTest02202 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02202");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02203.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02203.java
new file mode 100644
index 0000000000000000000000000000000000000000..a140423ad4d6059aa516fcec3360f45d7b783a8a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02203.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02203")
+public class BenchmarkTest02203 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02203");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a31470 = param; // assign
+        StringBuilder b31470 = new StringBuilder(a31470); // stick in stringbuilder
+        b31470.append(" SafeStuff"); // append some safe content
+        b31470.replace(
+                b31470.length() - "Chars".length(),
+                b31470.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map31470 = new java.util.HashMap<String, Object>();
+        map31470.put("key31470", b31470.toString()); // put in a collection
+        String c31470 = (String) map31470.get("key31470"); // get it back out
+        String d31470 = c31470.substring(0, c31470.length() - 1); // extract most of it
+        String e31470 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d31470.getBytes()))); // B64 encode and decode it
+        String f31470 = e31470.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g31470 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g31470); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02204.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02204.java
new file mode 100644
index 0000000000000000000000000000000000000000..4327614d15906a5e1b8f21b653d5cd145c6492e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02204.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02204")
+public class BenchmarkTest02204 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02204");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02205.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02205.java
new file mode 100644
index 0000000000000000000000000000000000000000..c57b130ed3a60530c8001ef9dd97c40eafcb0dd1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02205.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02205")
+public class BenchmarkTest02205 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02205");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02206.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02206.java
new file mode 100644
index 0000000000000000000000000000000000000000..173151b1c313417d0ccab35f9cf73db4707f01de
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02206.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02206")
+public class BenchmarkTest02206 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02206");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02207.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02207.java
new file mode 100644
index 0000000000000000000000000000000000000000..a290a4a8eaa4d3823524df2725304186f6b56c45
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02207.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02207")
+public class BenchmarkTest02207 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02207");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02208.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02208.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae515f6090b6973608a70d3b784591b3bdb2c114
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02208.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02208")
+public class BenchmarkTest02208 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02208");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02209.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02209.java
new file mode 100644
index 0000000000000000000000000000000000000000..415fa9d6c8ccf5db8e17332da09bf816ff9da5b3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02209.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02209")
+public class BenchmarkTest02209 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02209");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02210.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02210.java
new file mode 100644
index 0000000000000000000000000000000000000000..181142bfb9e08d10b2c3318b626e928f76efddf1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02210.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02210")
+public class BenchmarkTest02210 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02210");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02211.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02211.java
new file mode 100644
index 0000000000000000000000000000000000000000..13220ddf65f55159c82b9da28ac241cf5b4ede2f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02211.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02211")
+public class BenchmarkTest02211 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02211");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02212.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02212.java
new file mode 100644
index 0000000000000000000000000000000000000000..986306b2eac66dd10dacac0e0d6516cf176f9391
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02212.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02212")
+public class BenchmarkTest02212 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02212");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02213.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02213.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd5109e6630bf537a410deb4f2754c7f38b80cc7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02213.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02213")
+public class BenchmarkTest02213 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02213");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02214.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02214.java
new file mode 100644
index 0000000000000000000000000000000000000000..94707e9507c91c5ef3a51ae664ac808ddb04ace7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02214.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02214")
+public class BenchmarkTest02214 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02214");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02215.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02215.java
new file mode 100644
index 0000000000000000000000000000000000000000..7075d546328e150fe45509262cb534775499c506
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02215.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02215")
+public class BenchmarkTest02215 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02215");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02216.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02216.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a7d54704144fb6af0a97fec4b827ecf2b9363c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02216.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02216")
+public class BenchmarkTest02216 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02216");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02217.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02217.java
new file mode 100644
index 0000000000000000000000000000000000000000..6cf2eb1ae5e7d1c3cd42a45e1880778ca774b40d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02217.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02217")
+public class BenchmarkTest02217 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02217");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02218.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02218.java
new file mode 100644
index 0000000000000000000000000000000000000000..16f430804bb6eb8794fce099136c07c9b34d5889
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02218.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02218")
+public class BenchmarkTest02218 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02218");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02219.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02219.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ad6be04c6f194df11bc33c37b4b04a2db976221
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02219.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02219")
+public class BenchmarkTest02219 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02219");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02220.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02220.java
new file mode 100644
index 0000000000000000000000000000000000000000..555cb5e031f7066b3211c0093f499456d191f41f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02220.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02220")
+public class BenchmarkTest02220 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02220");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a19972 = param; // assign
+        StringBuilder b19972 = new StringBuilder(a19972); // stick in stringbuilder
+        b19972.append(" SafeStuff"); // append some safe content
+        b19972.replace(
+                b19972.length() - "Chars".length(),
+                b19972.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map19972 = new java.util.HashMap<String, Object>();
+        map19972.put("key19972", b19972.toString()); // put in a collection
+        String c19972 = (String) map19972.get("key19972"); // get it back out
+        String d19972 = c19972.substring(0, c19972.length() - 1); // extract most of it
+        String e19972 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d19972.getBytes()))); // B64 encode and decode it
+        String f19972 = e19972.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f19972); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02221.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02221.java
new file mode 100644
index 0000000000000000000000000000000000000000..efd105e3ae2a8e4ff0f3a2bf863dd8151f3bf363
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02221.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02221")
+public class BenchmarkTest02221 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02221");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz71523 = new StringBuilder(param);
+            bar = sbxyz71523.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02222.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02222.java
new file mode 100644
index 0000000000000000000000000000000000000000..791944d24b77502d1c865098720a6931ac8ed666
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02222.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02222")
+public class BenchmarkTest02222 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02222");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02223.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02223.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9c0df2ac54205b6d5cdaac6f6fab5b2704e8d12
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02223.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02223")
+public class BenchmarkTest02223 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02223");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz60073 = new StringBuilder(param);
+        String bar = sbxyz60073.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02224.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02224.java
new file mode 100644
index 0000000000000000000000000000000000000000..437db9f2390be2362bbb6730c5f9e0187f8d4cd0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02224.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02224")
+public class BenchmarkTest02224 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02224");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02225.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02225.java
new file mode 100644
index 0000000000000000000000000000000000000000..9bd913e33c87333c8062666bc26242e1f55d6113
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02225.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02225")
+public class BenchmarkTest02225 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02225");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map73885 = new java.util.HashMap<String, Object>();
+        map73885.put("keyA-73885", "a-Value"); // put some stuff in the collection
+        map73885.put("keyB-73885", param); // put it in a collection
+        map73885.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map73885.get("keyB-73885"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02226.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02226.java
new file mode 100644
index 0000000000000000000000000000000000000000..591ae1e3483f270bb28e9bde0c0ecbad5bac38ef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02226.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02226")
+public class BenchmarkTest02226 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02226");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02227.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02227.java
new file mode 100644
index 0000000000000000000000000000000000000000..281de76335e46ae3c30ec8df5434b4144a16eae9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02227.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02227")
+public class BenchmarkTest02227 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02227");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz39187 = new StringBuilder(param);
+        String bar = sbxyz39187.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02228.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02228.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e307115197809ace5f1e4a6095a60d4d867a3b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02228.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02228")
+public class BenchmarkTest02228 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02228");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz60124 = new StringBuilder(param);
+        String bar = sbxyz60124.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02229.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02229.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb698ed988908a3397ac333f907ab91676be4333
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02229.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02229")
+public class BenchmarkTest02229 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02229");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map26903 = new java.util.HashMap<String, Object>();
+        map26903.put("keyA-26903", "a_Value"); // put some stuff in the collection
+        map26903.put("keyB-26903", param); // put it in a collection
+        map26903.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map26903.get("keyB-26903"); // get it back out
+        bar = (String) map26903.get("keyA-26903"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02230.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02230.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5280d4fd1ed2263a4ca33f0582165aa0fee8b1e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02230.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02230")
+public class BenchmarkTest02230 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02230");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz51189 = new StringBuilder(param);
+            bar = sbxyz51189.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02231.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02231.java
new file mode 100644
index 0000000000000000000000000000000000000000..87561d0de936073ebb28fe2b57af76c2eaa51f4d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02231.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02231")
+public class BenchmarkTest02231 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02231");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a60610 = param; // assign
+        StringBuilder b60610 = new StringBuilder(a60610); // stick in stringbuilder
+        b60610.append(" SafeStuff"); // append some safe content
+        b60610.replace(
+                b60610.length() - "Chars".length(),
+                b60610.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map60610 = new java.util.HashMap<String, Object>();
+        map60610.put("key60610", b60610.toString()); // put in a collection
+        String c60610 = (String) map60610.get("key60610"); // get it back out
+        String d60610 = c60610.substring(0, c60610.length() - 1); // extract most of it
+        String e60610 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d60610.getBytes()))); // B64 encode and decode it
+        String f60610 = e60610.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g60610 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g60610); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02232.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02232.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2f81ab093d4877771dffdb86eb85cfad6c27219
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02232.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02232")
+public class BenchmarkTest02232 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02232");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02233.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02233.java
new file mode 100644
index 0000000000000000000000000000000000000000..6264f4dd4cc2a3c2914c2052b82e53bc854a566e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02233.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02233")
+public class BenchmarkTest02233 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02233");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02234.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02234.java
new file mode 100644
index 0000000000000000000000000000000000000000..a9a261ffacb48ac6a839916ce96cba93e096781e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02234.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02234")
+public class BenchmarkTest02234 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02234");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz86132 = new StringBuilder(param);
+        String bar = sbxyz86132.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02235.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02235.java
new file mode 100644
index 0000000000000000000000000000000000000000..a39f9182600e2a7b66a73de1779c90978bec508e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02235.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02235")
+public class BenchmarkTest02235 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02235");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02236.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02236.java
new file mode 100644
index 0000000000000000000000000000000000000000..588fd9e428a2b0e68ccb12be675cdeb8c7b81953
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02236.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02236")
+public class BenchmarkTest02236 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02236");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02237.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02237.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce85a33377a3663c9776da6ba2241d3222244950
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02237.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02237")
+public class BenchmarkTest02237 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02237");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02238.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02238.java
new file mode 100644
index 0000000000000000000000000000000000000000..2dee540c661be7734f188e6c8304c0f71717b99d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02238.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02238")
+public class BenchmarkTest02238 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02238");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a16227 = param; // assign
+        StringBuilder b16227 = new StringBuilder(a16227); // stick in stringbuilder
+        b16227.append(" SafeStuff"); // append some safe content
+        b16227.replace(
+                b16227.length() - "Chars".length(),
+                b16227.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map16227 = new java.util.HashMap<String, Object>();
+        map16227.put("key16227", b16227.toString()); // put in a collection
+        String c16227 = (String) map16227.get("key16227"); // get it back out
+        String d16227 = c16227.substring(0, c16227.length() - 1); // extract most of it
+        String e16227 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d16227.getBytes()))); // B64 encode and decode it
+        String f16227 = e16227.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g16227 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g16227); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02239.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02239.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f87d7d9a0fee8350723fe439c4df752bb4c1b81
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02239.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02239")
+public class BenchmarkTest02239 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02239");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02240.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02240.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2075d826b3e3c8197b4e8e913a22600363c6cc8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02240.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02240")
+public class BenchmarkTest02240 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02240");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02241.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02241.java
new file mode 100644
index 0000000000000000000000000000000000000000..e75470201e52c230a84ed6c54f060d84ad5342e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02241.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02241")
+public class BenchmarkTest02241 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02241");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02242.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02242.java
new file mode 100644
index 0000000000000000000000000000000000000000..6071da35c702565e0d9690f67698473af2d99bc3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02242.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02242")
+public class BenchmarkTest02242 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02242");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a91595 = param; // assign
+        StringBuilder b91595 = new StringBuilder(a91595); // stick in stringbuilder
+        b91595.append(" SafeStuff"); // append some safe content
+        b91595.replace(
+                b91595.length() - "Chars".length(),
+                b91595.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map91595 = new java.util.HashMap<String, Object>();
+        map91595.put("key91595", b91595.toString()); // put in a collection
+        String c91595 = (String) map91595.get("key91595"); // get it back out
+        String d91595 = c91595.substring(0, c91595.length() - 1); // extract most of it
+        String e91595 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d91595.getBytes()))); // B64 encode and decode it
+        String f91595 = e91595.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g91595 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g91595); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02243.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02243.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b1d8a106139a5fe7ac56e2ef83b9fbcbf96e032
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02243.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02243")
+public class BenchmarkTest02243 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02243");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map19941 = new java.util.HashMap<String, Object>();
+        map19941.put("keyA-19941", "a-Value"); // put some stuff in the collection
+        map19941.put("keyB-19941", param); // put it in a collection
+        map19941.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map19941.get("keyB-19941"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02244.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02244.java
new file mode 100644
index 0000000000000000000000000000000000000000..af87b247af3b1bfc50dd4c612b33742ac2793096
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02244.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02244")
+public class BenchmarkTest02244 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02244");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02245.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02245.java
new file mode 100644
index 0000000000000000000000000000000000000000..27912bce7a56d82630c658a114595ec6db80e1fe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02245.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02245")
+public class BenchmarkTest02245 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02245");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02246.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02246.java
new file mode 100644
index 0000000000000000000000000000000000000000..b12040cc23a1df1e09534ded93da8005282b8334
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02246.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02246")
+public class BenchmarkTest02246 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02246");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map19712 = new java.util.HashMap<String, Object>();
+        map19712.put("keyA-19712", "a-Value"); // put some stuff in the collection
+        map19712.put("keyB-19712", param); // put it in a collection
+        map19712.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map19712.get("keyB-19712"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02247.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02247.java
new file mode 100644
index 0000000000000000000000000000000000000000..11abfece60209188758a380895d67c23ffbf0171
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02247.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02247")
+public class BenchmarkTest02247 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02247");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02248.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02248.java
new file mode 100644
index 0000000000000000000000000000000000000000..21740ec944de2516f2b1e647e75512e1b40e4cf9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02248.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02248")
+public class BenchmarkTest02248 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02248");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02249.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02249.java
new file mode 100644
index 0000000000000000000000000000000000000000..738b041f9f243a67f834f04ca8e7f48790766250
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02249.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02249")
+public class BenchmarkTest02249 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02249");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02250.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02250.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f6af948dc87f238b7d310709395d82f32e49131
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02250.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02250")
+public class BenchmarkTest02250 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02250");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map94176 = new java.util.HashMap<String, Object>();
+        map94176.put("keyA-94176", "a-Value"); // put some stuff in the collection
+        map94176.put("keyB-94176", param); // put it in a collection
+        map94176.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map94176.get("keyB-94176"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02251.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02251.java
new file mode 100644
index 0000000000000000000000000000000000000000..9666ccc95feb0d8ef3630d438e8f3d48639eafb3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02251.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02251")
+public class BenchmarkTest02251 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02251");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02252.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02252.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a0cc1024769cfd6897af915f24ba033236877e0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02252.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02252")
+public class BenchmarkTest02252 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02252");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02253.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02253.java
new file mode 100644
index 0000000000000000000000000000000000000000..813ac02e47563d121aac229d03bdc20cd0ed821d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02253.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02253")
+public class BenchmarkTest02253 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02253");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02254.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02254.java
new file mode 100644
index 0000000000000000000000000000000000000000..6747b41571e4fd6156dd953a087ce0880bdfc98b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02254.java	
@@ -0,0 +1,113 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02254")
+public class BenchmarkTest02254 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02254");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02255.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02255.java
new file mode 100644
index 0000000000000000000000000000000000000000..328108b741e36c1a03b6da0564841b82bd8a3b92
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02255.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02255")
+public class BenchmarkTest02255 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02255");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02256.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02256.java
new file mode 100644
index 0000000000000000000000000000000000000000..8f370a98a06ca7de9c3ab4070653e2b803c7e911
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02256.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02256")
+public class BenchmarkTest02256 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02256");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02257.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02257.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e3847872725002d04b7fcb37d57b38bcd7683c9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02257.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02257")
+public class BenchmarkTest02257 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02257");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02258.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02258.java
new file mode 100644
index 0000000000000000000000000000000000000000..0323c49348e6bcaac941cb55ed14513f7e4f0b3d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02258.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02258")
+public class BenchmarkTest02258 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02258");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02259.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02259.java
new file mode 100644
index 0000000000000000000000000000000000000000..c44dac4c1c319ff148c87f7f0a611b3251fb7fde
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02259.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02259")
+public class BenchmarkTest02259 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02259");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02260.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02260.java
new file mode 100644
index 0000000000000000000000000000000000000000..b34a8f5746512cadc0816dbb46daa1b8ffc49bfb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02260.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02260")
+public class BenchmarkTest02260 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02260");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02261.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02261.java
new file mode 100644
index 0000000000000000000000000000000000000000..601d5bbd31361f69bbe9a412f35ad48195d1e943
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02261.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02261")
+public class BenchmarkTest02261 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02261");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02262.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02262.java
new file mode 100644
index 0000000000000000000000000000000000000000..88cc0d1d6ba14c1ab89819d7784c30228676e39e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02262.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02262")
+public class BenchmarkTest02262 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02262");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02263.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02263.java
new file mode 100644
index 0000000000000000000000000000000000000000..76f3580aad525b5d2f24f808e2e180f196b1480e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02263.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02263")
+public class BenchmarkTest02263 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02263");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02264.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02264.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d183927ca13e9ac864f79c8357ca630dce03000
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02264.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02264")
+public class BenchmarkTest02264 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02264");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02265.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02265.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ffdcc8f6db597e943654a07df4b657d2aab69ab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02265.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02265")
+public class BenchmarkTest02265 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02265");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02266.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02266.java
new file mode 100644
index 0000000000000000000000000000000000000000..b12f8c45266b1c937eea8a2e496355a30ebf7134
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02266.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02266")
+public class BenchmarkTest02266 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02266");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02267.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02267.java
new file mode 100644
index 0000000000000000000000000000000000000000..f7db975ac62013eee57c7bfa300dc20914c462e1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02267.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02267")
+public class BenchmarkTest02267 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02267");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02268.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02268.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d1528c0d676866dfe8ed5ef289c864a9af02e66
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02268.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02268")
+public class BenchmarkTest02268 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02268");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map95440 = new java.util.HashMap<String, Object>();
+        map95440.put("keyA-95440", "a_Value"); // put some stuff in the collection
+        map95440.put("keyB-95440", param); // put it in a collection
+        map95440.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map95440.get("keyB-95440"); // get it back out
+        bar = (String) map95440.get("keyA-95440"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02269.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02269.java
new file mode 100644
index 0000000000000000000000000000000000000000..254f02d7c668220f01b7a5132b2ce43ccd7a02c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02269.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02269")
+public class BenchmarkTest02269 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02269");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02270.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02270.java
new file mode 100644
index 0000000000000000000000000000000000000000..1bea97bebe391da399806250544b6f907d5d1c39
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02270.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02270")
+public class BenchmarkTest02270 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02270");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02271.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02271.java
new file mode 100644
index 0000000000000000000000000000000000000000..a63d789637880cd378329b04027e09e18155335a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02271.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02271")
+public class BenchmarkTest02271 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02271");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02272.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02272.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a3b15462fba1fefd1b57257f081a87b6bd5722e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02272.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02272")
+public class BenchmarkTest02272 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02272");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02273.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02273.java
new file mode 100644
index 0000000000000000000000000000000000000000..399538fb4ff43f96fb8c09b670c44748843f8a99
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02273.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02273")
+public class BenchmarkTest02273 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02273");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02274.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02274.java
new file mode 100644
index 0000000000000000000000000000000000000000..acecac2e825e78dae04b12ab566e0c183d2ee227
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02274.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02274")
+public class BenchmarkTest02274 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02274");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02275.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02275.java
new file mode 100644
index 0000000000000000000000000000000000000000..90965c9ed109d2c67fa61fc3283de3d814b364d9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02275.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-04/BenchmarkTest02275")
+public class BenchmarkTest02275 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02275");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02276.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02276.java
new file mode 100644
index 0000000000000000000000000000000000000000..963960efc06728e07c7735ac79dae894c4076c28
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02276.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02276")
+public class BenchmarkTest02276 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02276");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // int results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForInt(sql);
+            Integer results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Integer.class);
+            response.getWriter().println("Your results are: " + results);
+            //		System.out.println("Your results are: " + results);
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02277.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02277.java
new file mode 100644
index 0000000000000000000000000000000000000000..e474a27908bdecbe357f06efca47bcc6e3341608
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02277.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02277")
+public class BenchmarkTest02277 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02277");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02278.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02278.java
new file mode 100644
index 0000000000000000000000000000000000000000..c88f6dff91416798c3c4104a5555fba8d0b52a8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02278.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02278")
+public class BenchmarkTest02278 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02278");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map96698 = new java.util.HashMap<String, Object>();
+        map96698.put("keyA-96698", "a_Value"); // put some stuff in the collection
+        map96698.put("keyB-96698", param); // put it in a collection
+        map96698.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map96698.get("keyB-96698"); // get it back out
+        bar = (String) map96698.get("keyA-96698"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02279.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02279.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2dd03d86d22c59f2310d72fec4d0224254308b2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02279.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02279")
+public class BenchmarkTest02279 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02279");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02280.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02280.java
new file mode 100644
index 0000000000000000000000000000000000000000..6763bc8a58c5cd0a2d86d97486faf56da2b0f31d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02280.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02280")
+public class BenchmarkTest02280 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02280");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02281.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02281.java
new file mode 100644
index 0000000000000000000000000000000000000000..39078dc33b04dec580c8c0018fd7aa426f7e0be3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02281.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02281")
+public class BenchmarkTest02281 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02281");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02282.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02282.java
new file mode 100644
index 0000000000000000000000000000000000000000..a6b304dd3db4f43f0919dbdafd96199de5540a32
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02282.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02282")
+public class BenchmarkTest02282 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02282");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02283.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02283.java
new file mode 100644
index 0000000000000000000000000000000000000000..f48d6921b2fa435a88d12d90e08ac224c93b25eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02283.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02283")
+public class BenchmarkTest02283 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02283");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02284.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02284.java
new file mode 100644
index 0000000000000000000000000000000000000000..0bf9bb36b55c5ee32b6197296bfa801606263609
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02284.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02284")
+public class BenchmarkTest02284 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02284");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02285.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02285.java
new file mode 100644
index 0000000000000000000000000000000000000000..982f8d5b93ea059fd5260b04a4ce63b0547d8cbb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02285.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02285")
+public class BenchmarkTest02285 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02285");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02286.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02286.java
new file mode 100644
index 0000000000000000000000000000000000000000..c3c4bd38674eb620886ba84efffea3cda46aca4c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02286.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02286")
+public class BenchmarkTest02286 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02286");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02287.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02287.java
new file mode 100644
index 0000000000000000000000000000000000000000..18d7f9670c7efa4a58752fb51583255d2e45e325
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02287.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02287")
+public class BenchmarkTest02287 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02287");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02288.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02288.java
new file mode 100644
index 0000000000000000000000000000000000000000..65b889090acecca82e52b45b757462b69c027249
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02288.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02288")
+public class BenchmarkTest02288 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        java.util.Map<String, String[]> map = request.getParameterMap();
+        String param = "";
+        if (!map.isEmpty()) {
+            String[] values = map.get("BenchmarkTest02288");
+            if (values != null) param = values[0];
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02289.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02289.java
new file mode 100644
index 0000000000000000000000000000000000000000..62b6195df266079ee2c6100bfa283c50dc76712d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02289.java	
@@ -0,0 +1,153 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02289")
+public class BenchmarkTest02289 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02289")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02290.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02290.java
new file mode 100644
index 0000000000000000000000000000000000000000..343ed57c037fac95dcd95dc67e932560651fad53
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02290.java	
@@ -0,0 +1,163 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02290")
+public class BenchmarkTest02290 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02290")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02291.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02291.java
new file mode 100644
index 0000000000000000000000000000000000000000..c13e35c079d7e8b9bbb98b6c6a4d4c05280206a7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02291.java	
@@ -0,0 +1,177 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02291")
+public class BenchmarkTest02291 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02291")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a10347 = param; // assign
+        StringBuilder b10347 = new StringBuilder(a10347); // stick in stringbuilder
+        b10347.append(" SafeStuff"); // append some safe content
+        b10347.replace(
+                b10347.length() - "Chars".length(),
+                b10347.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map10347 = new java.util.HashMap<String, Object>();
+        map10347.put("key10347", b10347.toString()); // put in a collection
+        String c10347 = (String) map10347.get("key10347"); // get it back out
+        String d10347 = c10347.substring(0, c10347.length() - 1); // extract most of it
+        String e10347 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d10347.getBytes()))); // B64 encode and decode it
+        String f10347 = e10347.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g10347 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g10347); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02292.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02292.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf42f53803f318e6df61cfb0c810834157cc9724
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02292.java	
@@ -0,0 +1,156 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02292")
+public class BenchmarkTest02292 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02292")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02293.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02293.java
new file mode 100644
index 0000000000000000000000000000000000000000..7e87338c542b13911e943abfae480ee65eaf7cd2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02293.java	
@@ -0,0 +1,142 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02293")
+public class BenchmarkTest02293 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02293")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a87246 = param; // assign
+        StringBuilder b87246 = new StringBuilder(a87246); // stick in stringbuilder
+        b87246.append(" SafeStuff"); // append some safe content
+        b87246.replace(
+                b87246.length() - "Chars".length(),
+                b87246.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map87246 = new java.util.HashMap<String, Object>();
+        map87246.put("key87246", b87246.toString()); // put in a collection
+        String c87246 = (String) map87246.get("key87246"); // get it back out
+        String d87246 = c87246.substring(0, c87246.length() - 1); // extract most of it
+        String e87246 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d87246.getBytes()))); // B64 encode and decode it
+        String f87246 = e87246.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f87246); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02294.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02294.java
new file mode 100644
index 0000000000000000000000000000000000000000..40b8089d9a5517b80f7edb14b708796a4dcb97ab
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02294.java	
@@ -0,0 +1,127 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02294")
+public class BenchmarkTest02294 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02294")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02295.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02295.java
new file mode 100644
index 0000000000000000000000000000000000000000..545ef632050bf3ed1c7936f207dac81a1a5587ba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02295.java	
@@ -0,0 +1,127 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02295")
+public class BenchmarkTest02295 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02295")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02296.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02296.java
new file mode 100644
index 0000000000000000000000000000000000000000..3a1eede7f6fa7566c739474a1df18cb3499b4b45
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02296.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02296")
+public class BenchmarkTest02296 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02296")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02297.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02297.java
new file mode 100644
index 0000000000000000000000000000000000000000..df8ea920b85ec92d5ba2287c8013e6ec0f0cbe52
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02297.java	
@@ -0,0 +1,128 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02297")
+public class BenchmarkTest02297 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02297")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02298.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02298.java
new file mode 100644
index 0000000000000000000000000000000000000000..2744013314c2f3b01d11ebb2b650a388b2ba03ba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02298.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02298")
+public class BenchmarkTest02298 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02298")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02299.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02299.java
new file mode 100644
index 0000000000000000000000000000000000000000..b77b893f5796decd5b37bdda47507508620b5f59
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02299.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02299")
+public class BenchmarkTest02299 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02299")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02300.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02300.java
new file mode 100644
index 0000000000000000000000000000000000000000..3bc0e094319c0c5f087848bdc4961304f4624fd8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02300.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02300")
+public class BenchmarkTest02300 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02300")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a20919 = param; // assign
+        StringBuilder b20919 = new StringBuilder(a20919); // stick in stringbuilder
+        b20919.append(" SafeStuff"); // append some safe content
+        b20919.replace(
+                b20919.length() - "Chars".length(),
+                b20919.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map20919 = new java.util.HashMap<String, Object>();
+        map20919.put("key20919", b20919.toString()); // put in a collection
+        String c20919 = (String) map20919.get("key20919"); // get it back out
+        String d20919 = c20919.substring(0, c20919.length() - 1); // extract most of it
+        String e20919 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d20919.getBytes()))); // B64 encode and decode it
+        String f20919 = e20919.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g20919 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g20919); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02301.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02301.java
new file mode 100644
index 0000000000000000000000000000000000000000..a389021047027ce50f9535ba8575a4910a14ef01
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02301.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02301")
+public class BenchmarkTest02301 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02301")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02302.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02302.java
new file mode 100644
index 0000000000000000000000000000000000000000..f054f29b0fa63326d4de57a815c58ac36f54531a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02302.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02302")
+public class BenchmarkTest02302 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02302")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02303.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02303.java
new file mode 100644
index 0000000000000000000000000000000000000000..26dd1a6e5de82dad2d367449c703c1e8cced7868
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02303.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02303")
+public class BenchmarkTest02303 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02303")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02304.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02304.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c5b3177d562d996d6f4d03da2db5577172f963c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02304.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02304")
+public class BenchmarkTest02304 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02304")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02305.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02305.java
new file mode 100644
index 0000000000000000000000000000000000000000..e5f7156a450903e507f1bfb154f90d636f9fb513
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02305.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02305")
+public class BenchmarkTest02305 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02305")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02306.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02306.java
new file mode 100644
index 0000000000000000000000000000000000000000..8dd37666098b92ba5db5d5eba881f0733ce53ea1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02306.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02306")
+public class BenchmarkTest02306 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02306")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02307.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02307.java
new file mode 100644
index 0000000000000000000000000000000000000000..811eb75c194cda90da028d5ca8cb1874ebde4fbd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02307.java	
@@ -0,0 +1,133 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02307")
+public class BenchmarkTest02307 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02307")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02308.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02308.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ffcc0bcce158c5b34c1baa361f5baf800656316
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02308.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02308")
+public class BenchmarkTest02308 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02308")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02309.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02309.java
new file mode 100644
index 0000000000000000000000000000000000000000..d16e11352feca20ceefe31050ba33772cfd91694
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02309.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02309")
+public class BenchmarkTest02309 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02309")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02310.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02310.java
new file mode 100644
index 0000000000000000000000000000000000000000..df0af348a8806e56990ab880e1a73c6269eede83
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02310.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02310")
+public class BenchmarkTest02310 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02310")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md =
+                    java.security.MessageDigest.getInstance("SHA-512", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02311.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02311.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d831fba2fbcd5da84bd8844fc77dbb0f6a914b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02311.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02311")
+public class BenchmarkTest02311 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02311")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02312.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02312.java
new file mode 100644
index 0000000000000000000000000000000000000000..139be23d12610e93b1569646a3d1e5dea28d3233
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02312.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02312")
+public class BenchmarkTest02312 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02312")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02313.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02313.java
new file mode 100644
index 0000000000000000000000000000000000000000..4e3a377cf825432f66b2bca56489dc10e0614a9b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02313.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02313")
+public class BenchmarkTest02313 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02313")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a31085 = param; // assign
+        StringBuilder b31085 = new StringBuilder(a31085); // stick in stringbuilder
+        b31085.append(" SafeStuff"); // append some safe content
+        b31085.replace(
+                b31085.length() - "Chars".length(),
+                b31085.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map31085 = new java.util.HashMap<String, Object>();
+        map31085.put("key31085", b31085.toString()); // put in a collection
+        String c31085 = (String) map31085.get("key31085"); // get it back out
+        String d31085 = c31085.substring(0, c31085.length() - 1); // extract most of it
+        String e31085 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d31085.getBytes()))); // B64 encode and decode it
+        String f31085 = e31085.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g31085 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g31085); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02314.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02314.java
new file mode 100644
index 0000000000000000000000000000000000000000..362e028b3bc2594ebd1f2559b47d6736a3617434
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02314.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02314")
+public class BenchmarkTest02314 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02314")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02315.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02315.java
new file mode 100644
index 0000000000000000000000000000000000000000..77a286c9393bbcfdd3bb7749bdcd0c4572d95aae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02315.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02315")
+public class BenchmarkTest02315 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02315")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02316.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02316.java
new file mode 100644
index 0000000000000000000000000000000000000000..9092318c0378280f5f78559309342e2560f6952c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02316.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02316")
+public class BenchmarkTest02316 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02316")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02317.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02317.java
new file mode 100644
index 0000000000000000000000000000000000000000..ca28e561c7e83bf691b6e403c09f51bdc54237e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02317.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02317")
+public class BenchmarkTest02317 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02317")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02318.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02318.java
new file mode 100644
index 0000000000000000000000000000000000000000..655570168603813b10fd602134e6b6b180e9f07d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02318.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02318")
+public class BenchmarkTest02318 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02318")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02319.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02319.java
new file mode 100644
index 0000000000000000000000000000000000000000..8cf70d522960528b3530ad9c64353f06b7e1af94
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02319.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02319")
+public class BenchmarkTest02319 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02319")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02320.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02320.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd9307b69bca5db047bb0e5b034af6da5eedc27c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02320.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02320")
+public class BenchmarkTest02320 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02320")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02321.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02321.java
new file mode 100644
index 0000000000000000000000000000000000000000..7b69153defccfed0c5bef42aebe767b0571a821d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02321.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02321")
+public class BenchmarkTest02321 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02321")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a32510 = param; // assign
+        StringBuilder b32510 = new StringBuilder(a32510); // stick in stringbuilder
+        b32510.append(" SafeStuff"); // append some safe content
+        b32510.replace(
+                b32510.length() - "Chars".length(),
+                b32510.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map32510 = new java.util.HashMap<String, Object>();
+        map32510.put("key32510", b32510.toString()); // put in a collection
+        String c32510 = (String) map32510.get("key32510"); // get it back out
+        String d32510 = c32510.substring(0, c32510.length() - 1); // extract most of it
+        String e32510 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d32510.getBytes()))); // B64 encode and decode it
+        String f32510 = e32510.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f32510); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02322.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02322.java
new file mode 100644
index 0000000000000000000000000000000000000000..12a6533154193c8f156e6ca0fa6aca611f1952f4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02322.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02322")
+public class BenchmarkTest02322 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02322")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02323.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02323.java
new file mode 100644
index 0000000000000000000000000000000000000000..3199405fbec55a8b11c46ed90404ce26a1099028
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02323.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02323")
+public class BenchmarkTest02323 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02323")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02324.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02324.java
new file mode 100644
index 0000000000000000000000000000000000000000..f5cfa76951edfd8c127a12e4a71dfd480d6458ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02324.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02324")
+public class BenchmarkTest02324 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02324")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz12198 = new StringBuilder(param);
+            bar = sbxyz12198.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02325.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02325.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc8e79456ca044ca068ad6151d16c6fb24762f9a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02325.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02325")
+public class BenchmarkTest02325 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02325")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02326.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02326.java
new file mode 100644
index 0000000000000000000000000000000000000000..a4d5972a900f21e86fa31eec60d45d06df089d1e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02326.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02326")
+public class BenchmarkTest02326 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02326")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02327.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02327.java
new file mode 100644
index 0000000000000000000000000000000000000000..d90100434bc69e1d6a5e3d37759d86ae90482cda
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02327.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02327")
+public class BenchmarkTest02327 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02327")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02328.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02328.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0b938d79b86a0b0b90e7c1ea0df7e7311ca9f0f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02328.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02328")
+public class BenchmarkTest02328 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02328")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02329.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02329.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac2a6c51e9d889093b6b6fc5e80e9255e76f5f6c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02329.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02329")
+public class BenchmarkTest02329 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02329")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02330.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02330.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e1e7784b993f952498dae4a9095a9ddf1603334
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02330.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02330")
+public class BenchmarkTest02330 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02330")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02331.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02331.java
new file mode 100644
index 0000000000000000000000000000000000000000..2537629693da5f1e099253d54722b60527718530
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02331.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02331")
+public class BenchmarkTest02331 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02331")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02332.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02332.java
new file mode 100644
index 0000000000000000000000000000000000000000..ff9d50b98352d6cd88522a755da120e7020051b3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02332.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02332")
+public class BenchmarkTest02332 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02332")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02333.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02333.java
new file mode 100644
index 0000000000000000000000000000000000000000..82f0ad563d05bcac30eb692b5e6d206315cebadf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02333.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02333")
+public class BenchmarkTest02333 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02333")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02334.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02334.java
new file mode 100644
index 0000000000000000000000000000000000000000..b114660b7ca1764f04921aab657c462b78b591f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02334.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02334")
+public class BenchmarkTest02334 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02334")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02335.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02335.java
new file mode 100644
index 0000000000000000000000000000000000000000..8710d16404fe448c954d064b83a24a72d40d5417
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02335.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02335")
+public class BenchmarkTest02335 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02335")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02336.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02336.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6b90fdeae0778468112adf159e41c03ec315ec3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02336.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02336")
+public class BenchmarkTest02336 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02336")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a61280 = param; // assign
+        StringBuilder b61280 = new StringBuilder(a61280); // stick in stringbuilder
+        b61280.append(" SafeStuff"); // append some safe content
+        b61280.replace(
+                b61280.length() - "Chars".length(),
+                b61280.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map61280 = new java.util.HashMap<String, Object>();
+        map61280.put("key61280", b61280.toString()); // put in a collection
+        String c61280 = (String) map61280.get("key61280"); // get it back out
+        String d61280 = c61280.substring(0, c61280.length() - 1); // extract most of it
+        String e61280 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d61280.getBytes()))); // B64 encode and decode it
+        String f61280 = e61280.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g61280 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g61280); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02337.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02337.java
new file mode 100644
index 0000000000000000000000000000000000000000..060f4b81bb4060d24f7fe6502e3562929f22616c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02337.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02337")
+public class BenchmarkTest02337 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02337")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map19180 = new java.util.HashMap<String, Object>();
+        map19180.put("keyA-19180", "a_Value"); // put some stuff in the collection
+        map19180.put("keyB-19180", param); // put it in a collection
+        map19180.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map19180.get("keyB-19180"); // get it back out
+        bar = (String) map19180.get("keyA-19180"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02338.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02338.java
new file mode 100644
index 0000000000000000000000000000000000000000..826f24e106a4100b547952c37e38e17e4482d4b3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02338.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02338")
+public class BenchmarkTest02338 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02338")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02339.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02339.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed8e8ba20ad7238b1ae71b785cd7c46f3e3b2c12
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02339.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02339")
+public class BenchmarkTest02339 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02339")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02340.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02340.java
new file mode 100644
index 0000000000000000000000000000000000000000..2cc60e4e4bfd5f7eed2609b3a28fc35489c3663d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02340.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02340")
+public class BenchmarkTest02340 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02340")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02341.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02341.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c62aa011ac146d392d4d216398964fac021995a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02341.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02341")
+public class BenchmarkTest02341 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02341")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02342.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02342.java
new file mode 100644
index 0000000000000000000000000000000000000000..d04452d4b202226190b03f9da929e8be9b88c626
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02342.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02342")
+public class BenchmarkTest02342 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02342")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02343.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02343.java
new file mode 100644
index 0000000000000000000000000000000000000000..164279c352a8c5700d6f9fcae9e224d20d97de18
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02343.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02343")
+public class BenchmarkTest02343 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02343")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        String[] argsEnv = {"Foo=bar"};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p =
+                    r.exec(cmd + bar, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02344.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02344.java
new file mode 100644
index 0000000000000000000000000000000000000000..a617ac483e991f723baaed77d6b8b2dc5b6d45f3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02344.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02344")
+public class BenchmarkTest02344 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02344")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02345.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02345.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb2f1306c7323a81165fd88d1e59f9f3b2bcb7a8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02345.java	
@@ -0,0 +1,123 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02345")
+public class BenchmarkTest02345 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02345")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map60514 = new java.util.HashMap<String, Object>();
+        map60514.put("keyA-60514", "a-Value"); // put some stuff in the collection
+        map60514.put("keyB-60514", param); // put it in a collection
+        map60514.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map60514.get("keyB-60514"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02346.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02346.java
new file mode 100644
index 0000000000000000000000000000000000000000..3dc34008044cca5d0eb61b9d6e78ed322de44784
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02346.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02346")
+public class BenchmarkTest02346 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02346")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz9692 = new StringBuilder(param);
+            bar = sbxyz9692.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02347.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02347.java
new file mode 100644
index 0000000000000000000000000000000000000000..0da37b9e9084f50a38a2e59ad4f5bd8e85452036
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02347.java	
@@ -0,0 +1,128 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02347")
+public class BenchmarkTest02347 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02347")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02348.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02348.java
new file mode 100644
index 0000000000000000000000000000000000000000..186ca81ae12642d847dda9751ad55ac316e2173b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02348.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02348")
+public class BenchmarkTest02348 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02348")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map48532 = new java.util.HashMap<String, Object>();
+        map48532.put("keyA-48532", "a-Value"); // put some stuff in the collection
+        map48532.put("keyB-48532", param); // put it in a collection
+        map48532.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map48532.get("keyB-48532"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02349.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02349.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec8c5f012c546cf997ea865952fc21eaf1a934c1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02349.java	
@@ -0,0 +1,126 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02349")
+public class BenchmarkTest02349 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02349")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a55770 = param; // assign
+        StringBuilder b55770 = new StringBuilder(a55770); // stick in stringbuilder
+        b55770.append(" SafeStuff"); // append some safe content
+        b55770.replace(
+                b55770.length() - "Chars".length(),
+                b55770.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map55770 = new java.util.HashMap<String, Object>();
+        map55770.put("key55770", b55770.toString()); // put in a collection
+        String c55770 = (String) map55770.get("key55770"); // get it back out
+        String d55770 = c55770.substring(0, c55770.length() - 1); // extract most of it
+        String e55770 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d55770.getBytes()))); // B64 encode and decode it
+        String f55770 = e55770.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f55770); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02350.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02350.java
new file mode 100644
index 0000000000000000000000000000000000000000..882c031d1b1733d598cf29e9f236188b87e945a0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02350.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02350")
+public class BenchmarkTest02350 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02350")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02351.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02351.java
new file mode 100644
index 0000000000000000000000000000000000000000..bdcb958c301c3f0c648a6fa15c2e2feb48068529
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02351.java	
@@ -0,0 +1,126 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02351")
+public class BenchmarkTest02351 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02351")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a14991 = param; // assign
+        StringBuilder b14991 = new StringBuilder(a14991); // stick in stringbuilder
+        b14991.append(" SafeStuff"); // append some safe content
+        b14991.replace(
+                b14991.length() - "Chars".length(),
+                b14991.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map14991 = new java.util.HashMap<String, Object>();
+        map14991.put("key14991", b14991.toString()); // put in a collection
+        String c14991 = (String) map14991.get("key14991"); // get it back out
+        String d14991 = c14991.substring(0, c14991.length() - 1); // extract most of it
+        String e14991 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d14991.getBytes()))); // B64 encode and decode it
+        String f14991 = e14991.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f14991); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02352.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02352.java
new file mode 100644
index 0000000000000000000000000000000000000000..884f7f541f65087754f9af239bcd0f522f396d1f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02352.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02352")
+public class BenchmarkTest02352 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02352")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02353.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02353.java
new file mode 100644
index 0000000000000000000000000000000000000000..d2e05d89419c673ef34edd499678a123c3322b44
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02353.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02353")
+public class BenchmarkTest02353 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02353")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02354.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02354.java
new file mode 100644
index 0000000000000000000000000000000000000000..aab24d82beabaee8ff224f27893b3c3d11cf12c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02354.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02354")
+public class BenchmarkTest02354 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02354")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02355.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02355.java
new file mode 100644
index 0000000000000000000000000000000000000000..9d176aaa6189a08be2fcfb18e7663a4fa8f8563b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02355.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02355")
+public class BenchmarkTest02355 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02355")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02356.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02356.java
new file mode 100644
index 0000000000000000000000000000000000000000..5043eb5cf19b7f9a33af47f62a664d0331a7c3d6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02356.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02356")
+public class BenchmarkTest02356 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02356")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02357.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02357.java
new file mode 100644
index 0000000000000000000000000000000000000000..11f614e3451e81e4a0e70b49d4b8198e66678fe5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02357.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02357")
+public class BenchmarkTest02357 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02357")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02358.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02358.java
new file mode 100644
index 0000000000000000000000000000000000000000..ddf57e1e62ef3ed87b44aa207269e7859293d0c0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02358.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02358")
+public class BenchmarkTest02358 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02358")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02359.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02359.java
new file mode 100644
index 0000000000000000000000000000000000000000..6c23ad4b38b8e698cf81ea68be35ac3f7748c42b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02359.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02359")
+public class BenchmarkTest02359 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02359")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02360.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02360.java
new file mode 100644
index 0000000000000000000000000000000000000000..ecd029e45418f776b6e894cdc3637dc935e5b981
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02360.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02360")
+public class BenchmarkTest02360 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02360")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02361.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02361.java
new file mode 100644
index 0000000000000000000000000000000000000000..9fa8ca9a98e4d46b340056cbd595026a8554b698
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02361.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02361")
+public class BenchmarkTest02361 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02361")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02362.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02362.java
new file mode 100644
index 0000000000000000000000000000000000000000..d093773494bc7e0d09896829da3b96644b03d4f8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02362.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02362")
+public class BenchmarkTest02362 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02362")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02363.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02363.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d4a5cc44b497ab7af200bea029e55b9586ba6eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02363.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02363")
+public class BenchmarkTest02363 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02363")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a21456 = param; // assign
+        StringBuilder b21456 = new StringBuilder(a21456); // stick in stringbuilder
+        b21456.append(" SafeStuff"); // append some safe content
+        b21456.replace(
+                b21456.length() - "Chars".length(),
+                b21456.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map21456 = new java.util.HashMap<String, Object>();
+        map21456.put("key21456", b21456.toString()); // put in a collection
+        String c21456 = (String) map21456.get("key21456"); // get it back out
+        String d21456 = c21456.substring(0, c21456.length() - 1); // extract most of it
+        String e21456 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d21456.getBytes()))); // B64 encode and decode it
+        String f21456 = e21456.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g21456 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g21456); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02364.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02364.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ca5a9f7ccb8b2d801caed80c23f0627d2361ea9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02364.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02364")
+public class BenchmarkTest02364 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02364")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02365.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02365.java
new file mode 100644
index 0000000000000000000000000000000000000000..9778dde2af7b487d45961cdf5c823d5fb976e514
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02365.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02365")
+public class BenchmarkTest02365 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02365")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02366.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02366.java
new file mode 100644
index 0000000000000000000000000000000000000000..9cd77ce8b7b60f524e7404e3ca57135f68536649
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02366.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02366")
+public class BenchmarkTest02366 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02366")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02367.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02367.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce0ab618340262ae947da864a37db52f80c9d210
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02367.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02367")
+public class BenchmarkTest02367 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02367")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a41891 = param; // assign
+        StringBuilder b41891 = new StringBuilder(a41891); // stick in stringbuilder
+        b41891.append(" SafeStuff"); // append some safe content
+        b41891.replace(
+                b41891.length() - "Chars".length(),
+                b41891.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map41891 = new java.util.HashMap<String, Object>();
+        map41891.put("key41891", b41891.toString()); // put in a collection
+        String c41891 = (String) map41891.get("key41891"); // get it back out
+        String d41891 = c41891.substring(0, c41891.length() - 1); // extract most of it
+        String e41891 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d41891.getBytes()))); // B64 encode and decode it
+        String f41891 = e41891.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g41891 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g41891); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02368.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02368.java
new file mode 100644
index 0000000000000000000000000000000000000000..95cb9a6683fd1b879e94288823dcbe1830009484
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02368.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02368")
+public class BenchmarkTest02368 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02368")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02369.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02369.java
new file mode 100644
index 0000000000000000000000000000000000000000..d71dde738e9649403080f51b3e0cbe64532da8ef
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02369.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02369")
+public class BenchmarkTest02369 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02369")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02370.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02370.java
new file mode 100644
index 0000000000000000000000000000000000000000..268e4761dea0a45c60443447227382098b66c639
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02370.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest02370")
+public class BenchmarkTest02370 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String param = "";
+        boolean flag = true;
+        java.util.Enumeration<String> names = request.getParameterNames();
+        while (names.hasMoreElements() && flag) {
+            String name = (String) names.nextElement();
+            String[] values = request.getParameterValues(name);
+            if (values != null) {
+                for (int i = 0; i < values.length && flag; i++) {
+                    String value = values[i];
+                    if (value.equals("BenchmarkTest02370")) {
+                        param = name;
+                        flag = false;
+                    }
+                }
+            }
+        }
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            org.w3c.dom.NodeList nodeList =
+                    (org.w3c.dom.NodeList)
+                            xp.compile(expression)
+                                    .evaluate(xmlDocument, javax.xml.xpath.XPathConstants.NODESET);
+
+            response.getWriter().println("Your query results are: <br/>");
+
+            for (int i = 0; i < nodeList.getLength(); i++) {
+                org.w3c.dom.Element value = (org.w3c.dom.Element) nodeList.item(i);
+                response.getWriter().println(value.getTextContent() + "<br/>");
+            }
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02371.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02371.java
new file mode 100644
index 0000000000000000000000000000000000000000..544629cabce20953050aa009960a6af4482b970d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02371.java	
@@ -0,0 +1,141 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02371")
+public class BenchmarkTest02371 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02371");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02372.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02372.java
new file mode 100644
index 0000000000000000000000000000000000000000..8fa412d7e64da35f36eb9d52416d53bed52b795f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02372.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02372")
+public class BenchmarkTest02372 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02372");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c = org.owasp.benchmark.helpers.Utils.getCipher();
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02373.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02373.java
new file mode 100644
index 0000000000000000000000000000000000000000..78fad54b516ee63ad3f355dcb753bceabc0d22bc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02373.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02373")
+public class BenchmarkTest02373 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02373");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02374.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02374.java
new file mode 100644
index 0000000000000000000000000000000000000000..f4fdaa938f7e646b271b58f7152aa4f9877999b7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02374.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02374")
+public class BenchmarkTest02374 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02374");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02375.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02375.java
new file mode 100644
index 0000000000000000000000000000000000000000..527251ca99ce514816b43aac9f8c5abd0b641687
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02375.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02375")
+public class BenchmarkTest02375 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02375");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02376.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02376.java
new file mode 100644
index 0000000000000000000000000000000000000000..a2a359ff5c63534d2c66ca18eaeb321312275152
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02376.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02376")
+public class BenchmarkTest02376 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02376");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02377.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02377.java
new file mode 100644
index 0000000000000000000000000000000000000000..547acc805734e93658f76ba0d025722e1850b0de
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02377.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02377")
+public class BenchmarkTest02377 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02377");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02378.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02378.java
new file mode 100644
index 0000000000000000000000000000000000000000..4db7ff7c0ad5c22f328654507548e566d94e5824
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02378.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02378")
+public class BenchmarkTest02378 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02378");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02379.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02379.java
new file mode 100644
index 0000000000000000000000000000000000000000..80a1164de2936ca5e687a317b8f628849c360405
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02379.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02379")
+public class BenchmarkTest02379 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02379");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file",
+                            null,
+                            startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', java.io.File.separatorChar)
+                                            .replace(' ', '_')
+                                    + bar,
+                            null,
+                            null);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02380.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02380.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd7022a98d4456fc8d596cf2d17e2cf64258ae6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02380.java	
@@ -0,0 +1,87 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02380")
+public class BenchmarkTest02380 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02380");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName));
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a76789 = param; // assign
+        StringBuilder b76789 = new StringBuilder(a76789); // stick in stringbuilder
+        b76789.append(" SafeStuff"); // append some safe content
+        b76789.replace(
+                b76789.length() - "Chars".length(),
+                b76789.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map76789 = new java.util.HashMap<String, Object>();
+        map76789.put("key76789", b76789.toString()); // put in a collection
+        String c76789 = (String) map76789.get("key76789"); // get it back out
+        String d76789 = c76789.substring(0, c76789.length() - 1); // extract most of it
+        String e76789 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d76789.getBytes()))); // B64 encode and decode it
+        String f76789 = e76789.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g76789 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g76789); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02381.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02381.java
new file mode 100644
index 0000000000000000000000000000000000000000..53198c31f1b328d1a0cc59a15ca9b72d955a6af1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02381.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02381")
+public class BenchmarkTest02381 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02381");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map75774 = new java.util.HashMap<String, Object>();
+        map75774.put("keyA-75774", "a_Value"); // put some stuff in the collection
+        map75774.put("keyB-75774", param); // put it in a collection
+        map75774.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map75774.get("keyB-75774"); // get it back out
+        bar = (String) map75774.get("keyA-75774"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02382.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02382.java
new file mode 100644
index 0000000000000000000000000000000000000000..8530434a4e72f8b302b8976dd1c0bc430b2f90de
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02382.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02382")
+public class BenchmarkTest02382 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02382");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02383.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02383.java
new file mode 100644
index 0000000000000000000000000000000000000000..167717913ea05a5fcceae3ba68cb22512ed60f5b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02383.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02383")
+public class BenchmarkTest02383 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02383");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map53518 = new java.util.HashMap<String, Object>();
+        map53518.put("keyA-53518", "a-Value"); // put some stuff in the collection
+        map53518.put("keyB-53518", param); // put it in a collection
+        map53518.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map53518.get("keyB-53518"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02384.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02384.java
new file mode 100644
index 0000000000000000000000000000000000000000..49ad5b1a9669bf288f21954e5861d858c7b22f4f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02384.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02384")
+public class BenchmarkTest02384 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02384");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02385.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02385.java
new file mode 100644
index 0000000000000000000000000000000000000000..26676561202c2c06d26f19f9368cbf6c69c3973d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02385.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02385")
+public class BenchmarkTest02385 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02385");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02386.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02386.java
new file mode 100644
index 0000000000000000000000000000000000000000..b057fb7ed1a5eeba12ab7a98ddd3d7a3e3c836b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02386.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02386")
+public class BenchmarkTest02386 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02386");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02387.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02387.java
new file mode 100644
index 0000000000000000000000000000000000000000..95a439e953ac05eb4b22f763567557de33389378
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02387.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02387")
+public class BenchmarkTest02387 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02387");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map70399 = new java.util.HashMap<String, Object>();
+        map70399.put("keyA-70399", "a-Value"); // put some stuff in the collection
+        map70399.put("keyB-70399", param); // put it in a collection
+        map70399.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map70399.get("keyB-70399"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02388.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02388.java
new file mode 100644
index 0000000000000000000000000000000000000000..62c41efbaf5ae1665239077b2a3b82a0e09d6797
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02388.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02388")
+public class BenchmarkTest02388 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02388");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map94322 = new java.util.HashMap<String, Object>();
+        map94322.put("keyA-94322", "a_Value"); // put some stuff in the collection
+        map94322.put("keyB-94322", param); // put it in a collection
+        map94322.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map94322.get("keyB-94322"); // get it back out
+        bar = (String) map94322.get("keyA-94322"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02389.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02389.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc337a1d5c13f7585f08775f9b3caa3f778ef141
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02389.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02389")
+public class BenchmarkTest02389 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02389");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02390.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02390.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba77bcb29fcf2c78c8df42d087ad404fa2f28852
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02390.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02390")
+public class BenchmarkTest02390 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02390");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a73202 = param; // assign
+        StringBuilder b73202 = new StringBuilder(a73202); // stick in stringbuilder
+        b73202.append(" SafeStuff"); // append some safe content
+        b73202.replace(
+                b73202.length() - "Chars".length(),
+                b73202.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map73202 = new java.util.HashMap<String, Object>();
+        map73202.put("key73202", b73202.toString()); // put in a collection
+        String c73202 = (String) map73202.get("key73202"); // get it back out
+        String d73202 = c73202.substring(0, c73202.length() - 1); // extract most of it
+        String e73202 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d73202.getBytes()))); // B64 encode and decode it
+        String f73202 = e73202.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g73202 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g73202); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02391.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02391.java
new file mode 100644
index 0000000000000000000000000000000000000000..375c80476f0130ed8e70b7fdead07c29e9a846bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02391.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02391")
+public class BenchmarkTest02391 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02391");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02392.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02392.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c4c37caf17752f8cf06da989f09afcd51828d6f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02392.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02392")
+public class BenchmarkTest02392 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02392");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02393.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02393.java
new file mode 100644
index 0000000000000000000000000000000000000000..91b2e39414004434c3c4a0cabc8b2dde3bd0533c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02393.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02393")
+public class BenchmarkTest02393 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02393");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a24492 = param; // assign
+        StringBuilder b24492 = new StringBuilder(a24492); // stick in stringbuilder
+        b24492.append(" SafeStuff"); // append some safe content
+        b24492.replace(
+                b24492.length() - "Chars".length(),
+                b24492.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map24492 = new java.util.HashMap<String, Object>();
+        map24492.put("key24492", b24492.toString()); // put in a collection
+        String c24492 = (String) map24492.get("key24492"); // get it back out
+        String d24492 = c24492.substring(0, c24492.length() - 1); // extract most of it
+        String e24492 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d24492.getBytes()))); // B64 encode and decode it
+        String f24492 = e24492.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g24492 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g24492); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02394.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02394.java
new file mode 100644
index 0000000000000000000000000000000000000000..cfd452f3ec18744ea154778da90cd5c5f524bf76
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02394.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02394")
+public class BenchmarkTest02394 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02394");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02395.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02395.java
new file mode 100644
index 0000000000000000000000000000000000000000..e88344a42d8031bd7b2072ca7d6d716819652b47
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02395.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02395")
+public class BenchmarkTest02395 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02395");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().format("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02396.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02396.java
new file mode 100644
index 0000000000000000000000000000000000000000..c44e7e4d9c08060bd34254bbc16a2b6d0c511a7e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02396.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02396")
+public class BenchmarkTest02396 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02396");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a53479 = param; // assign
+        StringBuilder b53479 = new StringBuilder(a53479); // stick in stringbuilder
+        b53479.append(" SafeStuff"); // append some safe content
+        b53479.replace(
+                b53479.length() - "Chars".length(),
+                b53479.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map53479 = new java.util.HashMap<String, Object>();
+        map53479.put("key53479", b53479.toString()); // put in a collection
+        String c53479 = (String) map53479.get("key53479"); // get it back out
+        String d53479 = c53479.substring(0, c53479.length() - 1); // extract most of it
+        String e53479 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d53479.getBytes()))); // B64 encode and decode it
+        String f53479 = e53479.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f53479); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02397.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02397.java
new file mode 100644
index 0000000000000000000000000000000000000000..6d44824f5d3a6ff6829c9e69fd6d5c011b5bb62c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02397.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02397")
+public class BenchmarkTest02397 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02397");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02398.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02398.java
new file mode 100644
index 0000000000000000000000000000000000000000..6f16f53a7d62ac0a33cd952806fe5b88cadb2e52
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02398.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02398")
+public class BenchmarkTest02398 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02398");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02399.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02399.java
new file mode 100644
index 0000000000000000000000000000000000000000..8105b539a848ac301632eb094a7e99b8c2459142
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02399.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02399")
+public class BenchmarkTest02399 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02399");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02400.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02400.java
new file mode 100644
index 0000000000000000000000000000000000000000..400ae6236b339d82d4a32e4a41391ef8eba7ff69
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02400.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02400")
+public class BenchmarkTest02400 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02400");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02401.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02401.java
new file mode 100644
index 0000000000000000000000000000000000000000..066bad7d930aac4cee9974f9981abf068691617c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02401.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02401")
+public class BenchmarkTest02401 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02401");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02402.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02402.java
new file mode 100644
index 0000000000000000000000000000000000000000..1cbae7fedc334b2f55b6a5903af16c8f6e91cd38
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02402.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02402")
+public class BenchmarkTest02402 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02402");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map55396 = new java.util.HashMap<String, Object>();
+        map55396.put("keyA-55396", "a-Value"); // put some stuff in the collection
+        map55396.put("keyB-55396", param); // put it in a collection
+        map55396.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map55396.get("keyB-55396"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02403.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02403.java
new file mode 100644
index 0000000000000000000000000000000000000000..db69d76883f334f708389aef3ba2b09f5cfd00b9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02403.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02403")
+public class BenchmarkTest02403 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02403");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a34270 = param; // assign
+        StringBuilder b34270 = new StringBuilder(a34270); // stick in stringbuilder
+        b34270.append(" SafeStuff"); // append some safe content
+        b34270.replace(
+                b34270.length() - "Chars".length(),
+                b34270.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map34270 = new java.util.HashMap<String, Object>();
+        map34270.put("key34270", b34270.toString()); // put in a collection
+        String c34270 = (String) map34270.get("key34270"); // get it back out
+        String d34270 = c34270.substring(0, c34270.length() - 1); // extract most of it
+        String e34270 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d34270.getBytes()))); // B64 encode and decode it
+        String f34270 = e34270.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f34270); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02404.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02404.java
new file mode 100644
index 0000000000000000000000000000000000000000..1849c024a9d160c6ac6983e571cb153876bb8f36
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02404.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02404")
+public class BenchmarkTest02404 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02404");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02405.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02405.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8c426654daea2dba2be4992894940c28f48556c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02405.java	
@@ -0,0 +1,45 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02405")
+public class BenchmarkTest02405 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02405");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02406.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02406.java
new file mode 100644
index 0000000000000000000000000000000000000000..770c64dc43e872c03117931d7d3c76e721f7b9c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02406.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02406")
+public class BenchmarkTest02406 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02406");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02407.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02407.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a0383e7344a30ba9395cd5709734c11e57b984d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02407.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02407")
+public class BenchmarkTest02407 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02407");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz58438 = new StringBuilder(param);
+            bar = sbxyz58438.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02408.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02408.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bb8b8f431412ddecb64b9be357737333163ddee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02408.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02408")
+public class BenchmarkTest02408 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02408");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a67594 = param; // assign
+        StringBuilder b67594 = new StringBuilder(a67594); // stick in stringbuilder
+        b67594.append(" SafeStuff"); // append some safe content
+        b67594.replace(
+                b67594.length() - "Chars".length(),
+                b67594.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map67594 = new java.util.HashMap<String, Object>();
+        map67594.put("key67594", b67594.toString()); // put in a collection
+        String c67594 = (String) map67594.get("key67594"); // get it back out
+        String d67594 = c67594.substring(0, c67594.length() - 1); // extract most of it
+        String e67594 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d67594.getBytes()))); // B64 encode and decode it
+        String f67594 = e67594.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g67594 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g67594); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02409.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02409.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a865f2f6fbf727fc4292ce9546bddf4ccc6c8cb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02409.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02409")
+public class BenchmarkTest02409 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02409");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02410.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02410.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd11a7b16cd34815c42bf3def61c3b16594fb9d8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02410.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02410")
+public class BenchmarkTest02410 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02410");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz69687 = new StringBuilder(param);
+        String bar = sbxyz69687.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02411.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02411.java
new file mode 100644
index 0000000000000000000000000000000000000000..3fcb4295df280fa17586d35bf14226745dacb28e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02411.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02411")
+public class BenchmarkTest02411 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02411");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02412.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02412.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8545d23b690c9c2eaac1676c1d9cac12dfaa5f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02412.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02412")
+public class BenchmarkTest02412 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02412");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02413.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02413.java
new file mode 100644
index 0000000000000000000000000000000000000000..50a9aa4f938259517b80733a047977170c6dc80d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02413.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02413")
+public class BenchmarkTest02413 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02413");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02414.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02414.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e012441eaed2d95cfb19809f86910713bca7230
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02414.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02414")
+public class BenchmarkTest02414 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02414");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02415.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02415.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ee6921e9186f3d9c3de1e0edaee9ee0977b7ce3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02415.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02415")
+public class BenchmarkTest02415 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02415");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02416.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02416.java
new file mode 100644
index 0000000000000000000000000000000000000000..f6afe3db98467446115f1feb3052da5304067a3c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02416.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02416")
+public class BenchmarkTest02416 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02416");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map59148 = new java.util.HashMap<String, Object>();
+        map59148.put("keyA-59148", "a_Value"); // put some stuff in the collection
+        map59148.put("keyB-59148", param); // put it in a collection
+        map59148.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map59148.get("keyB-59148"); // get it back out
+        bar = (String) map59148.get("keyA-59148"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02417.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02417.java
new file mode 100644
index 0000000000000000000000000000000000000000..10558e0a083feda59916accef453255bbc30f3f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02417.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02417")
+public class BenchmarkTest02417 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02417");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02418.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02418.java
new file mode 100644
index 0000000000000000000000000000000000000000..a6a7d972efdedbd773f66c129b666125de7c1bf4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02418.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02418")
+public class BenchmarkTest02418 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02418");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02419.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02419.java
new file mode 100644
index 0000000000000000000000000000000000000000..96fceb70f543072608968299ee52e461b1663abc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02419.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02419")
+public class BenchmarkTest02419 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02419");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a8935 = param; // assign
+        StringBuilder b8935 = new StringBuilder(a8935); // stick in stringbuilder
+        b8935.append(" SafeStuff"); // append some safe content
+        b8935.replace(
+                b8935.length() - "Chars".length(),
+                b8935.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map8935 = new java.util.HashMap<String, Object>();
+        map8935.put("key8935", b8935.toString()); // put in a collection
+        String c8935 = (String) map8935.get("key8935"); // get it back out
+        String d8935 = c8935.substring(0, c8935.length() - 1); // extract most of it
+        String e8935 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d8935.getBytes()))); // B64 encode and decode it
+        String f8935 = e8935.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g8935 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g8935); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02420.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02420.java
new file mode 100644
index 0000000000000000000000000000000000000000..ac5e2b6dad443602f89872b7c1218219acc80088
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02420.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02420")
+public class BenchmarkTest02420 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02420");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02421.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02421.java
new file mode 100644
index 0000000000000000000000000000000000000000..8758ced69e8786fcc5a9376dfd129c1ae7f231b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02421.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02421")
+public class BenchmarkTest02421 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02421");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map85191 = new java.util.HashMap<String, Object>();
+        map85191.put("keyA-85191", "a_Value"); // put some stuff in the collection
+        map85191.put("keyB-85191", param); // put it in a collection
+        map85191.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map85191.get("keyB-85191"); // get it back out
+        bar = (String) map85191.get("keyA-85191"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02422.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02422.java
new file mode 100644
index 0000000000000000000000000000000000000000..d2c3908a97776cb695ca20bb21363859e8ddb837
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02422.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02422")
+public class BenchmarkTest02422 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02422");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02423.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02423.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ea7495e58c6081f0598c29dcf00e60098ffab48
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02423.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02423")
+public class BenchmarkTest02423 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02423");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        int randNumber = new java.util.Random().nextInt(99);
+        String rememberMeKey = Integer.toString(randNumber);
+
+        String user = "Inga";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a24134 = param; // assign
+        StringBuilder b24134 = new StringBuilder(a24134); // stick in stringbuilder
+        b24134.append(" SafeStuff"); // append some safe content
+        b24134.replace(
+                b24134.length() - "Chars".length(),
+                b24134.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map24134 = new java.util.HashMap<String, Object>();
+        map24134.put("key24134", b24134.toString()); // put in a collection
+        String c24134 = (String) map24134.get("key24134"); // get it back out
+        String d24134 = c24134.substring(0, c24134.length() - 1); // extract most of it
+        String e24134 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d24134.getBytes()))); // B64 encode and decode it
+        String f24134 = e24134.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f24134); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02424.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02424.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb10a85f2d63380ebbe263343d22783816384217
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02424.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02424")
+public class BenchmarkTest02424 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02424");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02425.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02425.java
new file mode 100644
index 0000000000000000000000000000000000000000..db9137e7bd9e9cd12aab2b53d6eeaf2fb1710a37
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02425.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02425")
+public class BenchmarkTest02425 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02425");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02426.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02426.java
new file mode 100644
index 0000000000000000000000000000000000000000..c1796e34663dfcda4c902235d1d9c962da1ff989
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02426.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02426")
+public class BenchmarkTest02426 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02426");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02427.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02427.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa77b3f622265af10e52340eb58f986611cba19d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02427.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02427")
+public class BenchmarkTest02427 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02427");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02428.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02428.java
new file mode 100644
index 0000000000000000000000000000000000000000..36f93cbf155cdad47af3c241cc29a4a24940a5da
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02428.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02428")
+public class BenchmarkTest02428 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02428");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd + bar);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map52815 = new java.util.HashMap<String, Object>();
+        map52815.put("keyA-52815", "a_Value"); // put some stuff in the collection
+        map52815.put("keyB-52815", param); // put it in a collection
+        map52815.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map52815.get("keyB-52815"); // get it back out
+        bar = (String) map52815.get("keyA-52815"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02429.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02429.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4d4657995a66f219470b4776c1baf524833d4cf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02429.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02429")
+public class BenchmarkTest02429 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02429");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("echo");
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ping -c1 ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02430.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02430.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c192f79038830cd7eb4e707dfd72c867f637d32
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02430.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02430")
+public class BenchmarkTest02430 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02430");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02431.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02431.java
new file mode 100644
index 0000000000000000000000000000000000000000..7487751a7dbb129e5d4acaabaec97dd71152fff5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02431.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02431")
+public class BenchmarkTest02431 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02431");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map58889 = new java.util.HashMap<String, Object>();
+        map58889.put("keyA-58889", "a-Value"); // put some stuff in the collection
+        map58889.put("keyB-58889", param); // put it in a collection
+        map58889.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map58889.get("keyB-58889"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02432.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02432.java
new file mode 100644
index 0000000000000000000000000000000000000000..8af4dffb0070347335300a5629097566a6850be1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02432.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02432")
+public class BenchmarkTest02432 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02432");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map15850 = new java.util.HashMap<String, Object>();
+        map15850.put("keyA-15850", "a-Value"); // put some stuff in the collection
+        map15850.put("keyB-15850", param); // put it in a collection
+        map15850.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map15850.get("keyB-15850"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02433.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02433.java
new file mode 100644
index 0000000000000000000000000000000000000000..769da3f463105cf0428cb82b6c81b76f6dd0b54a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02433.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02433")
+public class BenchmarkTest02433 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02433");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02434.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02434.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc41dedf955763024418d1ea736b747792554a5b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02434.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02434")
+public class BenchmarkTest02434 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02434");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map29737 = new java.util.HashMap<String, Object>();
+        map29737.put("keyA-29737", "a-Value"); // put some stuff in the collection
+        map29737.put("keyB-29737", param); // put it in a collection
+        map29737.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map29737.get("keyB-29737"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02435.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02435.java
new file mode 100644
index 0000000000000000000000000000000000000000..72cc7900f402ad27dcfa2d3b0503cdf2c50e3e86
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02435.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02435")
+public class BenchmarkTest02435 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02435");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02436.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02436.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9310ed35e8b55a97485e56099db61ac928d82e8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02436.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02436")
+public class BenchmarkTest02436 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02436");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02437.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02437.java
new file mode 100644
index 0000000000000000000000000000000000000000..a92b5cdc047b5de6719b87d7c046329028efd781
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02437.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02437")
+public class BenchmarkTest02437 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02437");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02438.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02438.java
new file mode 100644
index 0000000000000000000000000000000000000000..27d51c49a22ca5c709a827553c78ae52242efcff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02438.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02438")
+public class BenchmarkTest02438 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02438");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02439.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02439.java
new file mode 100644
index 0000000000000000000000000000000000000000..39c124badc99868132539e206951103ff13b9c21
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02439.java	
@@ -0,0 +1,122 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02439")
+public class BenchmarkTest02439 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02439");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02440.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02440.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea45ca43da9ad82ac7d761b676e85d4b7401fa37
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02440.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02440")
+public class BenchmarkTest02440 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02440");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map85251 = new java.util.HashMap<String, Object>();
+        map85251.put("keyA-85251", "a_Value"); // put some stuff in the collection
+        map85251.put("keyB-85251", param); // put it in a collection
+        map85251.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map85251.get("keyB-85251"); // get it back out
+        bar = (String) map85251.get("keyA-85251"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02441.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02441.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ccac497cc64f4d1519bf82b9daa0db191a0b2e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02441.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02441")
+public class BenchmarkTest02441 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02441");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02442.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02442.java
new file mode 100644
index 0000000000000000000000000000000000000000..64f0ddacb635c865bec2e2af73364c099a0d1f0c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02442.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02442")
+public class BenchmarkTest02442 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02442");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz18041 = new StringBuilder(param);
+            bar = sbxyz18041.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02443.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02443.java
new file mode 100644
index 0000000000000000000000000000000000000000..75d65edfa5a23d673e37f1d4053a2e5b6fd85488
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02443.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02443")
+public class BenchmarkTest02443 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02443");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02444.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02444.java
new file mode 100644
index 0000000000000000000000000000000000000000..412e6edefb7890e3176190547e437c7ccb992bb4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02444.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02444")
+public class BenchmarkTest02444 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02444");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02445.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02445.java
new file mode 100644
index 0000000000000000000000000000000000000000..528f81cb7fdc693d1325af7dfe02f33c20d13fc8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02445.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02445")
+public class BenchmarkTest02445 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02445");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02446.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02446.java
new file mode 100644
index 0000000000000000000000000000000000000000..bd287be4d738942a542bd1c513765a771453b150
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02446.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02446")
+public class BenchmarkTest02446 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02446");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02447.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02447.java
new file mode 100644
index 0000000000000000000000000000000000000000..63633052f3b644628f9c4c9de4334d0b9c6d5d37
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02447.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02447")
+public class BenchmarkTest02447 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02447");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02448.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02448.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4d536dace05c3aa91c733d8a600ee88c928fa2e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02448.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02448")
+public class BenchmarkTest02448 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02448");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02449.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02449.java
new file mode 100644
index 0000000000000000000000000000000000000000..a59eb838b4135e9a40df47486841adda33b44581
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02449.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02449")
+public class BenchmarkTest02449 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02449");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02450.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02450.java
new file mode 100644
index 0000000000000000000000000000000000000000..67aca9dbb4a431e380f357104d9b112c3a3a7dfe
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02450.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02450")
+public class BenchmarkTest02450 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02450");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02451.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02451.java
new file mode 100644
index 0000000000000000000000000000000000000000..9e18898a9458d20fe5f54d881e53430d6e4a2057
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02451.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02451")
+public class BenchmarkTest02451 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02451");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02452.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02452.java
new file mode 100644
index 0000000000000000000000000000000000000000..677e8c8eb652a937928ef86dc231f30541d0ea31
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02452.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02452")
+public class BenchmarkTest02452 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02452");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a91263 = param; // assign
+        StringBuilder b91263 = new StringBuilder(a91263); // stick in stringbuilder
+        b91263.append(" SafeStuff"); // append some safe content
+        b91263.replace(
+                b91263.length() - "Chars".length(),
+                b91263.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map91263 = new java.util.HashMap<String, Object>();
+        map91263.put("key91263", b91263.toString()); // put in a collection
+        String c91263 = (String) map91263.get("key91263"); // get it back out
+        String d91263 = c91263.substring(0, c91263.length() - 1); // extract most of it
+        String e91263 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d91263.getBytes()))); // B64 encode and decode it
+        String f91263 = e91263.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g91263 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g91263); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02453.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02453.java
new file mode 100644
index 0000000000000000000000000000000000000000..f002ad7a5b5509298208d7e4f1de7387c6fe99dd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02453.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02453")
+public class BenchmarkTest02453 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02453");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02454.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02454.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d9ca3e064adf06d7b96681d3ef8a051be894220
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02454.java	
@@ -0,0 +1,55 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02454")
+public class BenchmarkTest02454 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02454");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02455.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02455.java
new file mode 100644
index 0000000000000000000000000000000000000000..698656441f9d810fced04a6af12e168118bc6d04
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02455.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02455")
+public class BenchmarkTest02455 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02455");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02456.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02456.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed61938f285d919b8535c5a3a4808467f07d5036
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02456.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02456")
+public class BenchmarkTest02456 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02456");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new String[] {"USERNAME", "PASSWORD"});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02457.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02457.java
new file mode 100644
index 0000000000000000000000000000000000000000..27dc0ea5944356088290bcc1db7c9fdcdb14da7e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02457.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xpathi-00/BenchmarkTest02457")
+public class BenchmarkTest02457 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheParameter("BenchmarkTest02457");
+        if (param == null) param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.io.FileInputStream file =
+                    new java.io.FileInputStream(
+                            org.owasp.benchmark.helpers.Utils.getFileFromClasspath(
+                                    "employees.xml", this.getClass().getClassLoader()));
+            javax.xml.parsers.DocumentBuilderFactory builderFactory =
+                    javax.xml.parsers.DocumentBuilderFactory.newInstance();
+            // Prevent XXE
+            builderFactory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+            javax.xml.parsers.DocumentBuilder builder = builderFactory.newDocumentBuilder();
+            org.w3c.dom.Document xmlDocument = builder.parse(file);
+            javax.xml.xpath.XPathFactory xpf = javax.xml.xpath.XPathFactory.newInstance();
+            javax.xml.xpath.XPath xp = xpf.newXPath();
+
+            String expression = "/Employees/Employee[@emplid='" + bar + "']";
+            String result = xp.evaluate(expression, xmlDocument);
+
+            response.getWriter().println("Your query results are: " + result + "<br/>");
+
+        } catch (javax.xml.xpath.XPathExpressionException
+                | javax.xml.parsers.ParserConfigurationException
+                | org.xml.sax.SAXException e) {
+            response.getWriter()
+                    .println(
+                            "Error parsing XPath input: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(bar)
+                                    + "'");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02458.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02458.java
new file mode 100644
index 0000000000000000000000000000000000000000..97d6e0af976ceb436dbb7b189ec0cbdba58a99e6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02458.java	
@@ -0,0 +1,147 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02458")
+public class BenchmarkTest02458 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02458");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02459.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02459.java
new file mode 100644
index 0000000000000000000000000000000000000000..00d7edfcef60d458694788bdb4dbc9578e3552e0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02459.java	
@@ -0,0 +1,146 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02459")
+public class BenchmarkTest02459 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02459");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map56716 = new java.util.HashMap<String, Object>();
+        map56716.put("keyA-56716", "a-Value"); // put some stuff in the collection
+        map56716.put("keyB-56716", param); // put it in a collection
+        map56716.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map56716.get("keyB-56716"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02460.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02460.java
new file mode 100644
index 0000000000000000000000000000000000000000..b96b78aa24746cad114a9904ec960cb4caca64c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02460.java	
@@ -0,0 +1,160 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02460")
+public class BenchmarkTest02460 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02460");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02461.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02461.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb8152ed88485ea2771257309ef4b457e0474a96
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02461.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02461")
+public class BenchmarkTest02461 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02461");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02462.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02462.java
new file mode 100644
index 0000000000000000000000000000000000000000..a5e6c84d9ae1a09b80759550816a8058aa1a9563
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02462.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02462")
+public class BenchmarkTest02462 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02462");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02463.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02463.java
new file mode 100644
index 0000000000000000000000000000000000000000..7aff28067a73343e0db701e3448fffb74793118d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02463.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02463")
+public class BenchmarkTest02463 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02463");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR, bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02464.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02464.java
new file mode 100644
index 0000000000000000000000000000000000000000..5866139cdad3822069c57b07111eff16b5b3f2cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02464.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02464")
+public class BenchmarkTest02464 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02464");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02465.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02465.java
new file mode 100644
index 0000000000000000000000000000000000000000..0eb2ead93e8f2334380aaeeb8b691a68ea1eca84
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02465.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02465")
+public class BenchmarkTest02465 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02465");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02466.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02466.java
new file mode 100644
index 0000000000000000000000000000000000000000..355f709b7be70ae9a74958549d89f2f145ce1f75
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02466.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-02/BenchmarkTest02466")
+public class BenchmarkTest02466 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02466");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02467.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02467.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0f326d3bf8f0ec0a3ac168adf769e27386b407d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02467.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02467")
+public class BenchmarkTest02467 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02467");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a60326 = param; // assign
+        StringBuilder b60326 = new StringBuilder(a60326); // stick in stringbuilder
+        b60326.append(" SafeStuff"); // append some safe content
+        b60326.replace(
+                b60326.length() - "Chars".length(),
+                b60326.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map60326 = new java.util.HashMap<String, Object>();
+        map60326.put("key60326", b60326.toString()); // put in a collection
+        String c60326 = (String) map60326.get("key60326"); // get it back out
+        String d60326 = c60326.substring(0, c60326.length() - 1); // extract most of it
+        String e60326 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d60326.getBytes()))); // B64 encode and decode it
+        String f60326 = e60326.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g60326 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g60326); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02468.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02468.java
new file mode 100644
index 0000000000000000000000000000000000000000..3046efccdd7f162700c56a2f3c3b0fbf6d621441
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02468.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02468")
+public class BenchmarkTest02468 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02468");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02469.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02469.java
new file mode 100644
index 0000000000000000000000000000000000000000..e109de4756da17123b957dd45b94842b89b80a4e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02469.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02469")
+public class BenchmarkTest02469 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02469");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02470.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02470.java
new file mode 100644
index 0000000000000000000000000000000000000000..2ffac40bb56216590d4fa2beb74838e78de8a1bc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02470.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02470")
+public class BenchmarkTest02470 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02470");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02471.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02471.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb2360d7f390b6a468da02dcc34aec50836cd19e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02471.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02471")
+public class BenchmarkTest02471 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02471");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02472.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02472.java
new file mode 100644
index 0000000000000000000000000000000000000000..23bbb4cbe8e15f35eb09f03819645deb8bd72882
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02472.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02472")
+public class BenchmarkTest02472 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02472");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02473.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02473.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ba6fc9566f85a5e93c6655e10762f9632a5828b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02473.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02473")
+public class BenchmarkTest02473 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02473");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        double value = java.lang.Math.random();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Doug";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+        response.getWriter().println("Weak Randomness Test java.lang.Math.random() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map91880 = new java.util.HashMap<String, Object>();
+        map91880.put("keyA-91880", "a-Value"); // put some stuff in the collection
+        map91880.put("keyB-91880", param); // put it in a collection
+        map91880.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map91880.get("keyB-91880"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02474.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02474.java
new file mode 100644
index 0000000000000000000000000000000000000000..1bb250afe21972384d7c2a4c86813bcd7dae129c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02474.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02474")
+public class BenchmarkTest02474 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02474");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02475.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02475.java
new file mode 100644
index 0000000000000000000000000000000000000000..08a087ddcf95b9f1ece59e6149bf41ec8829e019
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02475.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02475")
+public class BenchmarkTest02475 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02475");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map43776 = new java.util.HashMap<String, Object>();
+        map43776.put("keyA-43776", "a-Value"); // put some stuff in the collection
+        map43776.put("keyB-43776", param); // put it in a collection
+        map43776.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map43776.get("keyB-43776"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02476.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02476.java
new file mode 100644
index 0000000000000000000000000000000000000000..6e7143328a2a8aecffcb89d1a51d6937eee61da4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02476.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02476")
+public class BenchmarkTest02476 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02476");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02477.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02477.java
new file mode 100644
index 0000000000000000000000000000000000000000..c9fd48a885aa9244a773a25a485be995976c824e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02477.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02477")
+public class BenchmarkTest02477 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02477");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a40743 = param; // assign
+        StringBuilder b40743 = new StringBuilder(a40743); // stick in stringbuilder
+        b40743.append(" SafeStuff"); // append some safe content
+        b40743.replace(
+                b40743.length() - "Chars".length(),
+                b40743.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map40743 = new java.util.HashMap<String, Object>();
+        map40743.put("key40743", b40743.toString()); // put in a collection
+        String c40743 = (String) map40743.get("key40743"); // get it back out
+        String d40743 = c40743.substring(0, c40743.length() - 1); // extract most of it
+        String e40743 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d40743.getBytes()))); // B64 encode and decode it
+        String f40743 = e40743.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g40743 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g40743); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02478.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02478.java
new file mode 100644
index 0000000000000000000000000000000000000000..923863b4ce28e7ae400380c349b2a377604823aa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02478.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02478")
+public class BenchmarkTest02478 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02478");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02479.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02479.java
new file mode 100644
index 0000000000000000000000000000000000000000..61fb26231eee1be75cb21745fe5031d2b17de589
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02479.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02479")
+public class BenchmarkTest02479 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02479");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02480.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02480.java
new file mode 100644
index 0000000000000000000000000000000000000000..8412d8430c362c5433047ae1d48f4a8f30b2e658
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02480.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02480")
+public class BenchmarkTest02480 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02480");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02481.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02481.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c60cb3a7467806fb4240829902b28b1526024f8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02481.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02481")
+public class BenchmarkTest02481 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02481");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02482.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02482.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c767de5f231d330e41965b26bf7a2c088e7dbc5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02482.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02482")
+public class BenchmarkTest02482 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02482");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02483.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02483.java
new file mode 100644
index 0000000000000000000000000000000000000000..17cae23ddc935b68608ea054bc2bedd34f2a7bfd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02483.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02483")
+public class BenchmarkTest02483 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02483");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02484.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02484.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb03309cf9d7e839a1acfb87ddfa9e937332af7d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02484.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02484")
+public class BenchmarkTest02484 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02484");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map12535 = new java.util.HashMap<String, Object>();
+        map12535.put("keyA-12535", "a_Value"); // put some stuff in the collection
+        map12535.put("keyB-12535", param); // put it in a collection
+        map12535.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map12535.get("keyB-12535"); // get it back out
+        bar = (String) map12535.get("keyA-12535"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02485.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02485.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4f66f9b32ba217cb2daf7d10f6ea47904f8800c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02485.java	
@@ -0,0 +1,54 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02485")
+public class BenchmarkTest02485 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02485");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02486.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02486.java
new file mode 100644
index 0000000000000000000000000000000000000000..2991f4cc0c7af550936925a79a987f041c0d91d4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02486.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-04/BenchmarkTest02486")
+public class BenchmarkTest02486 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02486");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz61588 = new StringBuilder(param);
+            bar = sbxyz61588.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02487.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02487.java
new file mode 100644
index 0000000000000000000000000000000000000000..275bdb4933480b05f6bcf8c865c470c17d658d0c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02487.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02487")
+public class BenchmarkTest02487 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02487");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02488.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02488.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb6e287cc902b88bc84dfdb8f2b9c2ab891fee77
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02488.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02488")
+public class BenchmarkTest02488 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02488");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02489.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02489.java
new file mode 100644
index 0000000000000000000000000000000000000000..02b3912b8618fc8b89e4a55384811fbe11c4ea8c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02489.java	
@@ -0,0 +1,44 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02489")
+public class BenchmarkTest02489 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02489");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02490.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02490.java
new file mode 100644
index 0000000000000000000000000000000000000000..fa52605318f0a532b17d26678300e310b43de969
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02490.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02490")
+public class BenchmarkTest02490 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02490");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a28523 = param; // assign
+        StringBuilder b28523 = new StringBuilder(a28523); // stick in stringbuilder
+        b28523.append(" SafeStuff"); // append some safe content
+        b28523.replace(
+                b28523.length() - "Chars".length(),
+                b28523.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map28523 = new java.util.HashMap<String, Object>();
+        map28523.put("key28523", b28523.toString()); // put in a collection
+        String c28523 = (String) map28523.get("key28523"); // get it back out
+        String d28523 = c28523.substring(0, c28523.length() - 1); // extract most of it
+        String e28523 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d28523.getBytes()))); // B64 encode and decode it
+        String f28523 = e28523.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g28523 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g28523); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02491.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02491.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0f588cfc55c80cc9c70939fb97b8f5c329c2813
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02491.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02491")
+public class BenchmarkTest02491 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02491");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a17852 = param; // assign
+        StringBuilder b17852 = new StringBuilder(a17852); // stick in stringbuilder
+        b17852.append(" SafeStuff"); // append some safe content
+        b17852.replace(
+                b17852.length() - "Chars".length(),
+                b17852.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map17852 = new java.util.HashMap<String, Object>();
+        map17852.put("key17852", b17852.toString()); // put in a collection
+        String c17852 = (String) map17852.get("key17852"); // get it back out
+        String d17852 = c17852.substring(0, c17852.length() - 1); // extract most of it
+        String e17852 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d17852.getBytes()))); // B64 encode and decode it
+        String f17852 = e17852.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g17852 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g17852); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02492.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02492.java
new file mode 100644
index 0000000000000000000000000000000000000000..cde6a7bca90ef80095b72e1206349bae8fa29971
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02492.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02492")
+public class BenchmarkTest02492 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02492");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02493.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02493.java
new file mode 100644
index 0000000000000000000000000000000000000000..f722bb904f46197feebfbc729a69594e9742ad5f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02493.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02493")
+public class BenchmarkTest02493 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02493");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map4720 = new java.util.HashMap<String, Object>();
+        map4720.put("keyA-4720", "a-Value"); // put some stuff in the collection
+        map4720.put("keyB-4720", param); // put it in a collection
+        map4720.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map4720.get("keyB-4720"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02494.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02494.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e9341c225a45c6a55664f6721e478e9d485b704
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02494.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02494")
+public class BenchmarkTest02494 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02494");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz57919 = new StringBuilder(param);
+            bar = sbxyz57919.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02495.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02495.java
new file mode 100644
index 0000000000000000000000000000000000000000..a61302570b074569b015d23feb93676108c5e6b9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02495.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02495")
+public class BenchmarkTest02495 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02495");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar, 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02496.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02496.java
new file mode 100644
index 0000000000000000000000000000000000000000..81e8a2d886b161f571396792c3ab2a3fbc291dcd
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02496.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02496")
+public class BenchmarkTest02496 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02496");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02497.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02497.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7245c8da40b3b7f2b3219cc7295a1c8bad52e4f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02497.java	
@@ -0,0 +1,110 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02497")
+public class BenchmarkTest02497 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02497");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a40533 = param; // assign
+        StringBuilder b40533 = new StringBuilder(a40533); // stick in stringbuilder
+        b40533.append(" SafeStuff"); // append some safe content
+        b40533.replace(
+                b40533.length() - "Chars".length(),
+                b40533.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map40533 = new java.util.HashMap<String, Object>();
+        map40533.put("key40533", b40533.toString()); // put in a collection
+        String c40533 = (String) map40533.get("key40533"); // get it back out
+        String d40533 = c40533.substring(0, c40533.length() - 1); // extract most of it
+        String e40533 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d40533.getBytes()))); // B64 encode and decode it
+        String f40533 = e40533.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g40533 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g40533); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02498.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02498.java
new file mode 100644
index 0000000000000000000000000000000000000000..64dbe98eac3fd0b0e02b59454d2b26dc2894cedc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02498.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02498")
+public class BenchmarkTest02498 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02498");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02499.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02499.java
new file mode 100644
index 0000000000000000000000000000000000000000..14fe9cee9cee7e7dcf5405f0b90caa9ee6fbca87
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02499.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02499")
+public class BenchmarkTest02499 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02499");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02500.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02500.java
new file mode 100644
index 0000000000000000000000000000000000000000..be7a948d557944dd886003f1cfa619b9faa93a15
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02500.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02500")
+public class BenchmarkTest02500 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02500");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02501.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02501.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d7e5243a1b558664fe0d43dc80f01139861c11f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02501.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02501")
+public class BenchmarkTest02501 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02501");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02502.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02502.java
new file mode 100644
index 0000000000000000000000000000000000000000..f472e682e9b38d0ad2b4e3c159f61177e2761e08
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02502.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02502")
+public class BenchmarkTest02502 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02502");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02503.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02503.java
new file mode 100644
index 0000000000000000000000000000000000000000..43fc446e268dd6f19c62680fba6285b8540e8721
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02503.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02503")
+public class BenchmarkTest02503 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02503");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a70407 = param; // assign
+        StringBuilder b70407 = new StringBuilder(a70407); // stick in stringbuilder
+        b70407.append(" SafeStuff"); // append some safe content
+        b70407.replace(
+                b70407.length() - "Chars".length(),
+                b70407.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map70407 = new java.util.HashMap<String, Object>();
+        map70407.put("key70407", b70407.toString()); // put in a collection
+        String c70407 = (String) map70407.get("key70407"); // get it back out
+        String d70407 = c70407.substring(0, c70407.length() - 1); // extract most of it
+        String e70407 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d70407.getBytes()))); // B64 encode and decode it
+        String f70407 = e70407.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g70407 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g70407); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02504.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02504.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb140a89c199414efbabed18f889ae67b1bcfa72
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02504.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02504")
+public class BenchmarkTest02504 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02504");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02505.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02505.java
new file mode 100644
index 0000000000000000000000000000000000000000..59bcdfe5617a1b72c6ad26164a9f5309dcc9128a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02505.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02505")
+public class BenchmarkTest02505 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02505");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02506.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02506.java
new file mode 100644
index 0000000000000000000000000000000000000000..48cbf5c7eb88ee06c8fded17f1fee7c23611c00f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02506.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02506")
+public class BenchmarkTest02506 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02506");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02507.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02507.java
new file mode 100644
index 0000000000000000000000000000000000000000..a1eb4a6fe5a3d2f15e33b8a67a37b80d50b9b40e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02507.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02507")
+public class BenchmarkTest02507 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02507");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02508.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02508.java
new file mode 100644
index 0000000000000000000000000000000000000000..f124014212b816b756810b8720bc4044ca798d83
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02508.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02508")
+public class BenchmarkTest02508 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02508");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02509.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02509.java
new file mode 100644
index 0000000000000000000000000000000000000000..05f50c7a86519d2eb6d7bc392c78aeceb3c706a7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02509.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02509")
+public class BenchmarkTest02509 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02509");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02510.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02510.java
new file mode 100644
index 0000000000000000000000000000000000000000..238a9ab206cffe519a3d4fb9c2aa50d7fcf6dd93
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02510.java	
@@ -0,0 +1,79 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02510")
+public class BenchmarkTest02510 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02510");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a11776 = param; // assign
+        StringBuilder b11776 = new StringBuilder(a11776); // stick in stringbuilder
+        b11776.append(" SafeStuff"); // append some safe content
+        b11776.replace(
+                b11776.length() - "Chars".length(),
+                b11776.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map11776 = new java.util.HashMap<String, Object>();
+        map11776.put("key11776", b11776.toString()); // put in a collection
+        String c11776 = (String) map11776.get("key11776"); // get it back out
+        String d11776 = c11776.substring(0, c11776.length() - 1); // extract most of it
+        String e11776 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d11776.getBytes()))); // B64 encode and decode it
+        String f11776 = e11776.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g11776 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g11776); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02511.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02511.java
new file mode 100644
index 0000000000000000000000000000000000000000..bab1408360e57487666cea15e3f32ef7355cb3ad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02511.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02511")
+public class BenchmarkTest02511 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02511");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02512.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02512.java
new file mode 100644
index 0000000000000000000000000000000000000000..67dec32ad24a1b87ae095eb458025eea68de7902
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02512.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02512")
+public class BenchmarkTest02512 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02512");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02513.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02513.java
new file mode 100644
index 0000000000000000000000000000000000000000..1238e0a5a5371b7eb35e98776198bd8255625fd7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02513.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02513")
+public class BenchmarkTest02513 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02513");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02514.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02514.java
new file mode 100644
index 0000000000000000000000000000000000000000..2c9452d4ba42a36dfcd49a51c77368036306876e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02514.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02514")
+public class BenchmarkTest02514 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02514");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02515.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02515.java
new file mode 100644
index 0000000000000000000000000000000000000000..318b1840cf56ca7dd68aa9c6875b33a98e56031b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02515.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02515")
+public class BenchmarkTest02515 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02515");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(cmd, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02516.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02516.java
new file mode 100644
index 0000000000000000000000000000000000000000..54334713debefc04e663ba2165bc21972e50722c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02516.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-02/BenchmarkTest02516")
+public class BenchmarkTest02516 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02516");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map74796 = new java.util.HashMap<String, Object>();
+        map74796.put("keyA-74796", "a-Value"); // put some stuff in the collection
+        map74796.put("keyB-74796", param); // put it in a collection
+        map74796.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map74796.get("keyB-74796"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02517.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02517.java
new file mode 100644
index 0000000000000000000000000000000000000000..606bc4e83cb97be4f89ca394e17c8ad6f264ebc6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02517.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02517")
+public class BenchmarkTest02517 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02517");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02518.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02518.java
new file mode 100644
index 0000000000000000000000000000000000000000..9adc8a851020742803272597c51eb34c9af1a402
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02518.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02518")
+public class BenchmarkTest02518 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02518");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02519.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02519.java
new file mode 100644
index 0000000000000000000000000000000000000000..0b4565c4e7c892589f6ab7c7aed8c3bc514cfa78
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02519.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02519")
+public class BenchmarkTest02519 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02519");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz84406 = new StringBuilder(param);
+            bar = sbxyz84406.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02520.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02520.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c894176b3a07c3e1df158006bf30a0dde961187
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02520.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02520")
+public class BenchmarkTest02520 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02520");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02521.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02521.java
new file mode 100644
index 0000000000000000000000000000000000000000..5d69fa1cec42460eb29b5880e86b64c0a7c7dfda
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02521.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02521")
+public class BenchmarkTest02521 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02521");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02522.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02522.java
new file mode 100644
index 0000000000000000000000000000000000000000..d1edd3bd14d131273b754a0c92e1dac2820b57c3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02522.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02522")
+public class BenchmarkTest02522 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02522");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02523.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02523.java
new file mode 100644
index 0000000000000000000000000000000000000000..903431b4dc782234890be12f38dc1d7a44da92ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02523.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02523")
+public class BenchmarkTest02523 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02523");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02524.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02524.java
new file mode 100644
index 0000000000000000000000000000000000000000..25c6a8bf1cc7f5878d48844439ba53fb00cb5d0a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02524.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02524")
+public class BenchmarkTest02524 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02524");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02525.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02525.java
new file mode 100644
index 0000000000000000000000000000000000000000..973ba4167e476784924d95663fed841e023eb3f9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02525.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02525")
+public class BenchmarkTest02525 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02525");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02526.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02526.java
new file mode 100644
index 0000000000000000000000000000000000000000..e4c67b24da4649447b34ffa28c00c300911448dc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02526.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02526")
+public class BenchmarkTest02526 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02526");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String,java.lang.Object^)
+        request.getSession().putValue("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02527.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02527.java
new file mode 100644
index 0000000000000000000000000000000000000000..12e6103dd30380f3fcf6bda919ad69b15fe222d5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02527.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02527")
+public class BenchmarkTest02527 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02527");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02528.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02528.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fcf2ee9f6145f49c32f7f06f36a425e79688708
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02528.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02528")
+public class BenchmarkTest02528 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02528");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02529.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02529.java
new file mode 100644
index 0000000000000000000000000000000000000000..b32a0021db512bca67f755acbd65a09915570111
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02529.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02529")
+public class BenchmarkTest02529 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02529");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map32022 = new java.util.HashMap<String, Object>();
+        map32022.put("keyA-32022", "a_Value"); // put some stuff in the collection
+        map32022.put("keyB-32022", param); // put it in a collection
+        map32022.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map32022.get("keyB-32022"); // get it back out
+        bar = (String) map32022.get("keyA-32022"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02530.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02530.java
new file mode 100644
index 0000000000000000000000000000000000000000..f938df0b1059e5dc13d15e01886b16b7386ac5fa
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02530.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02530")
+public class BenchmarkTest02530 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02530");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02531.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02531.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f2f984afd0da45dedfec6554168472cefb7c569
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02531.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02531")
+public class BenchmarkTest02531 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02531");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02532.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02532.java
new file mode 100644
index 0000000000000000000000000000000000000000..3571c6387eace5caa1c7b28c34d854f3972b88bf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02532.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02532")
+public class BenchmarkTest02532 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02532");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02533.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02533.java
new file mode 100644
index 0000000000000000000000000000000000000000..1bc8535a55a6146c15e22bd21717a069ba90a18a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02533.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02533")
+public class BenchmarkTest02533 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02533");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02534.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02534.java
new file mode 100644
index 0000000000000000000000000000000000000000..22ab385df3bf6a84f8d627e5b183b9a5e02d524d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02534.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02534")
+public class BenchmarkTest02534 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02534");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02535.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02535.java
new file mode 100644
index 0000000000000000000000000000000000000000..2902017534f40c578551c0e40af100f660aed686
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02535.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02535")
+public class BenchmarkTest02535 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02535");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02536.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02536.java
new file mode 100644
index 0000000000000000000000000000000000000000..59d0a4e1a38156b33e791623db563c19384d4c7c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02536.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02536")
+public class BenchmarkTest02536 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02536");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02537.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02537.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f414ac038656f75bd7f0d394ed5dd8bfce1aa10
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02537.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02537")
+public class BenchmarkTest02537 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02537");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02538.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02538.java
new file mode 100644
index 0000000000000000000000000000000000000000..381306cd4cd560d495d7b928df3174463511605b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02538.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02538")
+public class BenchmarkTest02538 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02538");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 USERNAME from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            Object results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, new Object[] {}, String.class);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a72634 = param; // assign
+        StringBuilder b72634 = new StringBuilder(a72634); // stick in stringbuilder
+        b72634.append(" SafeStuff"); // append some safe content
+        b72634.replace(
+                b72634.length() - "Chars".length(),
+                b72634.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map72634 = new java.util.HashMap<String, Object>();
+        map72634.put("key72634", b72634.toString()); // put in a collection
+        String c72634 = (String) map72634.get("key72634"); // get it back out
+        String d72634 = c72634.substring(0, c72634.length() - 1); // extract most of it
+        String e72634 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d72634.getBytes()))); // B64 encode and decode it
+        String f72634 = e72634.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g72634 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g72634); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02539.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02539.java
new file mode 100644
index 0000000000000000000000000000000000000000..7caa4241b418e659ad53528e7d6e257fdd9ed19b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02539.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02539")
+public class BenchmarkTest02539 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02539");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a9290 = param; // assign
+        StringBuilder b9290 = new StringBuilder(a9290); // stick in stringbuilder
+        b9290.append(" SafeStuff"); // append some safe content
+        b9290.replace(
+                b9290.length() - "Chars".length(),
+                b9290.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map9290 = new java.util.HashMap<String, Object>();
+        map9290.put("key9290", b9290.toString()); // put in a collection
+        String c9290 = (String) map9290.get("key9290"); // get it back out
+        String d9290 = c9290.substring(0, c9290.length() - 1); // extract most of it
+        String e9290 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d9290.getBytes()))); // B64 encode and decode it
+        String f9290 = e9290.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g9290 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g9290); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02540.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02540.java
new file mode 100644
index 0000000000000000000000000000000000000000..027a10be43915357c33629cf4435c0b674a111e2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02540.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02540")
+public class BenchmarkTest02540 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02540");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02541.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02541.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b6b5fe9622eb1cba84222750bac552c6e3ccbca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02541.java	
@@ -0,0 +1,60 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02541")
+public class BenchmarkTest02541 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02541");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02542.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02542.java
new file mode 100644
index 0000000000000000000000000000000000000000..4973ba42f1a764d0b403b0876d6387cb345d2698
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02542.java	
@@ -0,0 +1,56 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02542")
+public class BenchmarkTest02542 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02542");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02543.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02543.java
new file mode 100644
index 0000000000000000000000000000000000000000..ed36a5610ae881d3147833f6b8972c853ee914c0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02543.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02543")
+public class BenchmarkTest02543 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02543");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02544.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02544.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ac57543268705fea2e3d8e513d53812b9f01bb6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02544.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02544")
+public class BenchmarkTest02544 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02544");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02545.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02545.java
new file mode 100644
index 0000000000000000000000000000000000000000..c7ee76cdd9b4787c5786b90c0381f2033ea7b3ec
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02545.java	
@@ -0,0 +1,59 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02545")
+public class BenchmarkTest02545 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02545");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02546.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02546.java
new file mode 100644
index 0000000000000000000000000000000000000000..75788cb6563ce75144ff247ffa5671275bf29ab6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02546.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02546")
+public class BenchmarkTest02546 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String[] values = request.getParameterValues("BenchmarkTest02546");
+        String param;
+        if (values != null && values.length > 0) param = values[0];
+        else param = "";
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02547.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02547.java
new file mode 100644
index 0000000000000000000000000000000000000000..08f1c91b7dde73f5d98a6c9c68745acf9b4f5945
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02547.java	
@@ -0,0 +1,163 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02547")
+public class BenchmarkTest02547 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02547" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02547"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02547" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02548.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02548.java
new file mode 100644
index 0000000000000000000000000000000000000000..5fdde1f2ec73de76beec1e82d385fba9e89f0dae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02548.java	
@@ -0,0 +1,168 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02548")
+public class BenchmarkTest02548 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02548" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02548"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02548" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02549.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02549.java
new file mode 100644
index 0000000000000000000000000000000000000000..9af96c283c2604f313f28d27c361be5e95975110
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02549.java	
@@ -0,0 +1,167 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02549")
+public class BenchmarkTest02549 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02549" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02549"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02549" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding", "SunJCE");
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz12557 = new StringBuilder(param);
+        String bar = sbxyz12557.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02550.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02550.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f6183eb1d09972e653fb2a6975daa521206711f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02550.java	
@@ -0,0 +1,132 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02550")
+public class BenchmarkTest02550 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02550" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02550"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02550" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02551.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02551.java
new file mode 100644
index 0000000000000000000000000000000000000000..14644ba1f3cb7f1ba580d8b71e22b33b999d54d4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02551.java	
@@ -0,0 +1,128 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02551")
+public class BenchmarkTest02551 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02551" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02551"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02551" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz98255 = new StringBuilder(param);
+            bar = sbxyz98255.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02552.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02552.java
new file mode 100644
index 0000000000000000000000000000000000000000..09592dd859a771fe3636b7e03ffaf1d35e8147c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02552.java	
@@ -0,0 +1,138 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-02/BenchmarkTest02552")
+public class BenchmarkTest02552 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02552" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02552"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02552" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        //		java.security.SecureRandom random = new java.security.SecureRandom();
+        //		byte[] iv = random.generateSeed(16);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg2", "AES/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02553.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02553.java
new file mode 100644
index 0000000000000000000000000000000000000000..d59f92b63dff0861647cd69eba0117f11e72cf52
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02553.java	
@@ -0,0 +1,118 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02553")
+public class BenchmarkTest02553 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02553" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02553"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02553" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+            // System.out.println("Filter " + filter);
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    ctx.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map11026 = new java.util.HashMap<String, Object>();
+        map11026.put("keyA-11026", "a_Value"); // put some stuff in the collection
+        map11026.put("keyB-11026", param); // put it in a collection
+        map11026.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map11026.get("keyB-11026"); // get it back out
+        bar = (String) map11026.get("keyA-11026"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02554.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02554.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6536d05dc1b11273a714d21528a5f2ebadcc25b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02554.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02554")
+public class BenchmarkTest02554 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02554" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02554"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02554" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget =
+                new java.io.File(
+                        new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR), bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02555.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02555.java
new file mode 100644
index 0000000000000000000000000000000000000000..68343a90b93df35b67507b1e19e53e4ed3737f88
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02555.java	
@@ -0,0 +1,85 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02555")
+public class BenchmarkTest02555 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02555" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02555"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02555" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02556.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02556.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa90bc8f02296d816eb50c45a29394229cb4db13
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02556.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02556")
+public class BenchmarkTest02556 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02556" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02556"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02556" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar);
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02557.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02557.java
new file mode 100644
index 0000000000000000000000000000000000000000..7543d57f5f02bcd78c31afb8ec1877d77cb697b0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02557.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02557")
+public class BenchmarkTest02557 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02557" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02557"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02557" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02558.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02558.java
new file mode 100644
index 0000000000000000000000000000000000000000..91f391f7d427e4da8d6c49058b70e6eaaa7f36bb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02558.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02558")
+public class BenchmarkTest02558 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02558" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02558"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02558" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02559.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02559.java
new file mode 100644
index 0000000000000000000000000000000000000000..d898cc8d6749f86037df01d01f9f2444a06f8b42
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02559.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02559")
+public class BenchmarkTest02559 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02559" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02559"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02559" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // FILE URIs are tricky because they are different between Mac and Windows because of lack
+        // of standardization.
+        // Mac requires an extra slash for some reason.
+        String startURIslashes = "";
+        if (System.getProperty("os.name").indexOf("Windows") != -1)
+            if (System.getProperty("os.name").indexOf("Windows") != -1) startURIslashes = "/";
+            else startURIslashes = "//";
+
+        try {
+            java.net.URI fileURI =
+                    new java.net.URI(
+                            "file:"
+                                    + startURIslashes
+                                    + org.owasp.benchmark.helpers.Utils.TESTFILES_DIR
+                                            .replace('\\', '/')
+                                            .replace(' ', '_')
+                                    + bar);
+            java.io.File fileTarget = new java.io.File(fileURI);
+            response.getWriter()
+                    .println(
+                            "Access to file: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(fileTarget.toString())
+                                    + "' created.");
+            if (fileTarget.exists()) {
+                response.getWriter().println(" And file already exists.");
+            } else {
+                response.getWriter().println(" But file doesn't exist yet.");
+            }
+        } catch (java.net.URISyntaxException e) {
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02560.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02560.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a2fd72ef0d609f687197444b6f8141a100292d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02560.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02560")
+public class BenchmarkTest02560 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02560" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02560"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02560" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02561.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02561.java
new file mode 100644
index 0000000000000000000000000000000000000000..198f691e60c5d68faebe291b472b4173e99a746b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02561.java	
@@ -0,0 +1,101 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02561")
+public class BenchmarkTest02561 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02561" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02561"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02561" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02562.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02562.java
new file mode 100644
index 0000000000000000000000000000000000000000..35ef3f7e811f7ca48ad6da17ac29458bfc63b538
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02562.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02562")
+public class BenchmarkTest02562 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02562" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02562"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02562" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02563.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02563.java
new file mode 100644
index 0000000000000000000000000000000000000000..04f2cd9bd2d57398c712546c3dee530b2aaa2f9e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02563.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02563")
+public class BenchmarkTest02563 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02563" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02563"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02563" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a99746 = param; // assign
+        StringBuilder b99746 = new StringBuilder(a99746); // stick in stringbuilder
+        b99746.append(" SafeStuff"); // append some safe content
+        b99746.replace(
+                b99746.length() - "Chars".length(),
+                b99746.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map99746 = new java.util.HashMap<String, Object>();
+        map99746.put("key99746", b99746.toString()); // put in a collection
+        String c99746 = (String) map99746.get("key99746"); // get it back out
+        String d99746 = c99746.substring(0, c99746.length() - 1); // extract most of it
+        String e99746 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d99746.getBytes()))); // B64 encode and decode it
+        String f99746 = e99746.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g99746 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g99746); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02564.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02564.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f564a7c6413660e2ea204dd68005a863041b8eb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02564.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02564")
+public class BenchmarkTest02564 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02564" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02564"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02564" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(new java.io.File(fileName), false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02565.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02565.java
new file mode 100644
index 0000000000000000000000000000000000000000..5811af8d05bf288a3498acf54f2435348f373408
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02565.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02565")
+public class BenchmarkTest02565 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02565" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02565"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02565" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02566.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02566.java
new file mode 100644
index 0000000000000000000000000000000000000000..e9d284a60114f10f5432290fdb6eb68da6498d51
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02566.java	
@@ -0,0 +1,103 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02566")
+public class BenchmarkTest02566 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02566" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02566"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02566" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+        try (
+        // Create the file first so the test won't throw an exception if it doesn't exist.
+        // Note: Don't actually do this because this method signature could cause a tool to find
+        // THIS file constructor
+        // as a vuln, rather than the File signature we are trying to actually test.
+        // If necessary, just run the benchmark twice. The 1st run should create all the necessary
+        // files.
+        // new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar).createNewFile();
+
+        java.io.FileOutputStream fos =
+                new java.io.FileOutputStream(new java.io.FileInputStream(fileName).getFD()); ) {
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02567.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02567.java
new file mode 100644
index 0000000000000000000000000000000000000000..12ce8f9b9b7603a218896490d445d27f7b6d4d33
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02567.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02567")
+public class BenchmarkTest02567 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02567" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02567"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02567" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02568.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02568.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a5c016695bd1e8406684daccbfe31e4a6dd6627
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02568.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02568")
+public class BenchmarkTest02568 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02568" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02568"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02568" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02569.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02569.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b071da42cc6fc758a74beca793a7d7bd8212146
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02569.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02569")
+public class BenchmarkTest02569 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02569" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02569"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02569" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02570.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02570.java
new file mode 100644
index 0000000000000000000000000000000000000000..5c2115c87408c3ec036443e88933f77702b6da71
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02570.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02570")
+public class BenchmarkTest02570 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02570" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02570"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02570" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+        java.io.InputStream is = null;
+
+        try {
+            java.nio.file.Path path = java.nio.file.Paths.get(fileName);
+            is = java.nio.file.Files.newInputStream(path, java.nio.file.StandardOpenOption.READ);
+            byte[] b = new byte[1000];
+            int size = is.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+            is.close();
+        } catch (Exception e) {
+            System.out.println("Couldn't open InputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting InputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (is != null) {
+                try {
+                    is.close();
+                    is = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02571.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02571.java
new file mode 100644
index 0000000000000000000000000000000000000000..51bc9ea47da6e8552665e37409e602c521c4a8e4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02571.java	
@@ -0,0 +1,133 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02571")
+public class BenchmarkTest02571 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02571" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02571"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02571" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person))(|(uid=" + bar + ")(street={0}))";
+            Object[] filters = new Object[] {"The streetz 4 Ms bar"};
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, filters, sc);
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02572.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02572.java
new file mode 100644
index 0000000000000000000000000000000000000000..51d3197d20252f4a4200c889e44bbd893661e724
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02572.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/ldapi-00/BenchmarkTest02572")
+public class BenchmarkTest02572 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02572" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02572"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02572" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        org.owasp.benchmark.helpers.LDAPManager ads = new org.owasp.benchmark.helpers.LDAPManager();
+        try {
+            response.setContentType("text/html;charset=UTF-8");
+            String base = "ou=users,ou=system";
+            javax.naming.directory.SearchControls sc = new javax.naming.directory.SearchControls();
+            sc.setSearchScope(javax.naming.directory.SearchControls.SUBTREE_SCOPE);
+            String filter = "(&(objectclass=person)(uid=" + bar + "))";
+
+            javax.naming.directory.DirContext ctx = ads.getDirContext();
+            javax.naming.directory.InitialDirContext idc =
+                    (javax.naming.directory.InitialDirContext) ctx;
+            boolean found = false;
+            javax.naming.NamingEnumeration<javax.naming.directory.SearchResult> results =
+                    idc.search(base, filter, sc);
+
+            while (results.hasMore()) {
+                javax.naming.directory.SearchResult sr =
+                        (javax.naming.directory.SearchResult) results.next();
+                javax.naming.directory.Attributes attrs = sr.getAttributes();
+
+                javax.naming.directory.Attribute attr = attrs.get("uid");
+                javax.naming.directory.Attribute attr2 = attrs.get("street");
+                if (attr != null) {
+                    response.getWriter()
+                            .println(
+                                    "LDAP query results:<br>"
+                                            + "Record found with name "
+                                            + attr.get()
+                                            + "<br>"
+                                            + "Address: "
+                                            + attr2.get()
+                                            + "<br>");
+                    // System.out.println("record found " + attr.get());
+                    found = true;
+                }
+            }
+            if (!found) {
+                response.getWriter()
+                        .println(
+                                "LDAP query results: nothing found for query: "
+                                        + org.owasp.esapi.ESAPI.encoder().encodeForHTML(filter));
+            }
+        } catch (javax.naming.NamingException e) {
+            throw new ServletException(e);
+        } finally {
+            try {
+                ads.closeDirContext();
+            } catch (Exception e) {
+                throw new ServletException(e);
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02573.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02573.java
new file mode 100644
index 0000000000000000000000000000000000000000..bf0409a0c153be162ee59fd382e808aa2d2f33b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02573.java	
@@ -0,0 +1,126 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02573")
+public class BenchmarkTest02573 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02573" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02573"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02573" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02574.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02574.java
new file mode 100644
index 0000000000000000000000000000000000000000..e8a347d16c7e88cc52b83b428cf4a360867d02e7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02574.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02574")
+public class BenchmarkTest02574 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02574" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02574"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02574" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.lang.String)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02575.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02575.java
new file mode 100644
index 0000000000000000000000000000000000000000..209f2bb254fa3d84ab53802d8b6354ca407ebfb7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02575.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02575")
+public class BenchmarkTest02575 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02575" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02575"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02575" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02576.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02576.java
new file mode 100644
index 0000000000000000000000000000000000000000..e231aac59474bb8e52fd13ea351c917701b48a2d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02576.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02576")
+public class BenchmarkTest02576 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02576" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02576"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02576" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02577.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02577.java
new file mode 100644
index 0000000000000000000000000000000000000000..174694b454a4672d509c83ebb749230604ad2364
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02577.java	
@@ -0,0 +1,125 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02577")
+public class BenchmarkTest02577 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02577" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02577"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02577" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02578.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02578.java
new file mode 100644
index 0000000000000000000000000000000000000000..95572063098efcb6735e38dc3df346a2efa72ff2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02578.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02578")
+public class BenchmarkTest02578 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02578" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02578"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02578" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02579.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02579.java
new file mode 100644
index 0000000000000000000000000000000000000000..c658a2d994831324f864472ab9063e948fc2c893
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02579.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02579")
+public class BenchmarkTest02579 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02579" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02579"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02579" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02580.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02580.java
new file mode 100644
index 0000000000000000000000000000000000000000..9f08a21c15be13650b03b4452a5097b2a92adc29
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02580.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02580")
+public class BenchmarkTest02580 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02580" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02580"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02580" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz1658 = new StringBuilder(param);
+        String bar = sbxyz1658.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02581.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02581.java
new file mode 100644
index 0000000000000000000000000000000000000000..4c6e39518ba18ea763aed96f3386cb613d77378b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02581.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02581")
+public class BenchmarkTest02581 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02581" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02581"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02581" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02582.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02582.java
new file mode 100644
index 0000000000000000000000000000000000000000..e639c65d1894a0d87a0f63beff7d54cbeeea0907
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02582.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02582")
+public class BenchmarkTest02582 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02582" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02582"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02582" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz18070 = new StringBuilder(param);
+        String bar = sbxyz18070.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02583.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02583.java
new file mode 100644
index 0000000000000000000000000000000000000000..c25cdc27146ddf3279a93c9d0aba8ad66e5e1772
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02583.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02583")
+public class BenchmarkTest02583 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02583" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02583"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02583" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02584.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02584.java
new file mode 100644
index 0000000000000000000000000000000000000000..264f476e3642f84a1dd3c95e65ed706691a7469c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02584.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02584")
+public class BenchmarkTest02584 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02584" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02584"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02584" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz36210 = new StringBuilder(param);
+        String bar = sbxyz36210.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02585.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02585.java
new file mode 100644
index 0000000000000000000000000000000000000000..0ecf4722ce900fc725bdf8844b429f41b1e6fc79
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02585.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02585")
+public class BenchmarkTest02585 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02585" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02585"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02585" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02586.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02586.java
new file mode 100644
index 0000000000000000000000000000000000000000..e1aa4e6be7cf433258dd3be44f64c34dab19fcc6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02586.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02586")
+public class BenchmarkTest02586 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02586" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02586"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02586" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02587.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02587.java
new file mode 100644
index 0000000000000000000000000000000000000000..a56842dbf10aa18b80be55268b1df7e7617e2c93
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02587.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02587")
+public class BenchmarkTest02587 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02587" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02587"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02587" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a93081 = param; // assign
+        StringBuilder b93081 = new StringBuilder(a93081); // stick in stringbuilder
+        b93081.append(" SafeStuff"); // append some safe content
+        b93081.replace(
+                b93081.length() - "Chars".length(),
+                b93081.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map93081 = new java.util.HashMap<String, Object>();
+        map93081.put("key93081", b93081.toString()); // put in a collection
+        String c93081 = (String) map93081.get("key93081"); // get it back out
+        String d93081 = c93081.substring(0, c93081.length() - 1); // extract most of it
+        String e93081 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d93081.getBytes()))); // B64 encode and decode it
+        String f93081 = e93081.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f93081); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02588.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02588.java
new file mode 100644
index 0000000000000000000000000000000000000000..5f72e9463362f82b54edbac9e93d8be4a8cf6f8d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02588.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02588")
+public class BenchmarkTest02588 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02588" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02588"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02588" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a1227 = param; // assign
+        StringBuilder b1227 = new StringBuilder(a1227); // stick in stringbuilder
+        b1227.append(" SafeStuff"); // append some safe content
+        b1227.replace(
+                b1227.length() - "Chars".length(),
+                b1227.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map1227 = new java.util.HashMap<String, Object>();
+        map1227.put("key1227", b1227.toString()); // put in a collection
+        String c1227 = (String) map1227.get("key1227"); // get it back out
+        String d1227 = c1227.substring(0, c1227.length() - 1); // extract most of it
+        String e1227 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d1227.getBytes()))); // B64 encode and decode it
+        String f1227 = e1227.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f1227); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02589.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02589.java
new file mode 100644
index 0000000000000000000000000000000000000000..1502c9af2fc240810d322976a05729a38ddd5486
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02589.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02589")
+public class BenchmarkTest02589 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02589" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02589"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02589" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02590.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02590.java
new file mode 100644
index 0000000000000000000000000000000000000000..e815dd34272800c5ced1ec941a9923a73efd7bc8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02590.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02590")
+public class BenchmarkTest02590 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02590" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02590"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02590" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map35520 = new java.util.HashMap<String, Object>();
+        map35520.put("keyA-35520", "a_Value"); // put some stuff in the collection
+        map35520.put("keyB-35520", param); // put it in a collection
+        map35520.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map35520.get("keyB-35520"); // get it back out
+        bar = (String) map35520.get("keyA-35520"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02591.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02591.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e0ee96705d5c6da7cf3ef0480cb1cfd40820a01
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02591.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02591")
+public class BenchmarkTest02591 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02591" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02591"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02591" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz9811 = new StringBuilder(param);
+        String bar = sbxyz9811.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02592.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02592.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ad3a326d6376572b569088e981724e7ced6c55d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02592.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02592")
+public class BenchmarkTest02592 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02592" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02592"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02592" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {bar, "b"};
+        response.getWriter().printf("Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz52014 = new StringBuilder(param);
+            bar = sbxyz52014.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02593.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02593.java
new file mode 100644
index 0000000000000000000000000000000000000000..026e18cb52b5cb95f9caffc58de7465730d507a9
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02593.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02593")
+public class BenchmarkTest02593 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02593" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02593"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02593" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02594.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02594.java
new file mode 100644
index 0000000000000000000000000000000000000000..851a58473b761e6145d172d727cf3970fdaf2d9d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02594.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02594")
+public class BenchmarkTest02594 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02594" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02594"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02594" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02595.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02595.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee5615149031d6404f8acc690709f84689d2930c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02595.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02595")
+public class BenchmarkTest02595 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02595" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02595"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02595" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02596.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02596.java
new file mode 100644
index 0000000000000000000000000000000000000000..e84764802f3913be7b1d5287113716d386751b61
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02596.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02596")
+public class BenchmarkTest02596 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02596" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02596"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02596" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02597.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02597.java
new file mode 100644
index 0000000000000000000000000000000000000000..71e78368e06554f56ad73a9e489317d2c5cff3a7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02597.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02597")
+public class BenchmarkTest02597 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02597" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02597"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02597" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz19350 = new StringBuilder(param);
+            bar = sbxyz19350.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02598.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02598.java
new file mode 100644
index 0000000000000000000000000000000000000000..c4fefab81cef82973eee013312d96e03ec1b0172
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02598.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02598")
+public class BenchmarkTest02598 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02598" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02598"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02598" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02599.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02599.java
new file mode 100644
index 0000000000000000000000000000000000000000..a64786fcc69a6a323e565a65df6863712e3c402e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02599.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02599")
+public class BenchmarkTest02599 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02599" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02599"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02599" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02600.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02600.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec8b7ef5377d1c5186864225a16ca5d1aaffe141
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02600.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02600")
+public class BenchmarkTest02600 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02600" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02600"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02600" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02601.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02601.java
new file mode 100644
index 0000000000000000000000000000000000000000..e54eddb367847adab2fec981fcb8d89e43259184
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02601.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02601")
+public class BenchmarkTest02601 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02601" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02601"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02601" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        int length = 1;
+        if (bar != null) {
+            length = bar.length();
+            response.getWriter().write(bar.toCharArray(), 0, length);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02602.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02602.java
new file mode 100644
index 0000000000000000000000000000000000000000..42657debeee19d80583d3a7c138ddc9753d7f664
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02602.java	
@@ -0,0 +1,132 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02602")
+public class BenchmarkTest02602 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02602" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02602"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02602" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a3617 = param; // assign
+        StringBuilder b3617 = new StringBuilder(a3617); // stick in stringbuilder
+        b3617.append(" SafeStuff"); // append some safe content
+        b3617.replace(
+                b3617.length() - "Chars".length(),
+                b3617.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map3617 = new java.util.HashMap<String, Object>();
+        map3617.put("key3617", b3617.toString()); // put in a collection
+        String c3617 = (String) map3617.get("key3617"); // get it back out
+        String d3617 = c3617.substring(0, c3617.length() - 1); // extract most of it
+        String e3617 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d3617.getBytes()))); // B64 encode and decode it
+        String f3617 = e3617.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f3617); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02603.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02603.java
new file mode 100644
index 0000000000000000000000000000000000000000..97fdf9e9eeac07a9165b1309781128536f49ab86
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02603.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02603")
+public class BenchmarkTest02603 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02603" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02603"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02603" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02604.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02604.java
new file mode 100644
index 0000000000000000000000000000000000000000..18ad788c8eb19d985d5c082241c0678fa3b3edf5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02604.java	
@@ -0,0 +1,131 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02604")
+public class BenchmarkTest02604 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02604" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02604"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02604" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a92079 = param; // assign
+        StringBuilder b92079 = new StringBuilder(a92079); // stick in stringbuilder
+        b92079.append(" SafeStuff"); // append some safe content
+        b92079.replace(
+                b92079.length() - "Chars".length(),
+                b92079.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map92079 = new java.util.HashMap<String, Object>();
+        map92079.put("key92079", b92079.toString()); // put in a collection
+        String c92079 = (String) map92079.get("key92079"); // get it back out
+        String d92079 = c92079.substring(0, c92079.length() - 1); // extract most of it
+        String e92079 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d92079.getBytes()))); // B64 encode and decode it
+        String f92079 = e92079.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f92079); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02605.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02605.java
new file mode 100644
index 0000000000000000000000000000000000000000..006a393ceb87ea74f3d7f4106e5ea42bb7458432
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02605.java	
@@ -0,0 +1,116 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02605")
+public class BenchmarkTest02605 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02605" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02605"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02605" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02606.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02606.java
new file mode 100644
index 0000000000000000000000000000000000000000..4235c473ec1bfe55b71c39ea983e390b5bc77873
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02606.java	
@@ -0,0 +1,121 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02606")
+public class BenchmarkTest02606 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02606" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02606"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02606" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02607.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02607.java
new file mode 100644
index 0000000000000000000000000000000000000000..b03c545099461adddbde5f5888df49db8008dcbb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02607.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02607")
+public class BenchmarkTest02607 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02607" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02607"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02607" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz75490 = new StringBuilder(param);
+        String bar = sbxyz75490.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02608.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02608.java
new file mode 100644
index 0000000000000000000000000000000000000000..807b74a75b77c45f8fb1163550c70755aa1ba173
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02608.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02608")
+public class BenchmarkTest02608 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02608" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02608"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02608" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02609.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02609.java
new file mode 100644
index 0000000000000000000000000000000000000000..905f6a7fce93115717eb68ea32a25b552b1291fc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02609.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02609")
+public class BenchmarkTest02609 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02609" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02609"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02609" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02610.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02610.java
new file mode 100644
index 0000000000000000000000000000000000000000..0f7ea5e126e22544de643fbd3904079df81955ac
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02610.java	
@@ -0,0 +1,104 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02610")
+public class BenchmarkTest02610 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02610" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02610"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02610" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv);
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02611.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02611.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc2e3687539c291eef224001acdf30fb093b63be
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02611.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02611")
+public class BenchmarkTest02611 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02611" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02611"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02611" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd = "";
+        String a1 = "";
+        String a2 = "";
+        String[] args = null;
+        String osName = System.getProperty("os.name");
+
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+            cmd = "echo ";
+            args = new String[] {a1, a2, cmd, bar};
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+            cmd = org.owasp.benchmark.helpers.Utils.getOSCommandString("ls ");
+            args = new String[] {a1, a2, cmd + bar};
+        }
+
+        String[] argsEnv = {"foo=bar"};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02612.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02612.java
new file mode 100644
index 0000000000000000000000000000000000000000..89ba38d5daaec4cb8edf9811d71cca7359c4b94f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02612.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02612")
+public class BenchmarkTest02612 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02612" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02612"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02612" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02613.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02613.java
new file mode 100644
index 0000000000000000000000000000000000000000..0581648500d6b6932867e7ed7d748f502ae03eca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02613.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02613")
+public class BenchmarkTest02613 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02613" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02613"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02613" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02614.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02614.java
new file mode 100644
index 0000000000000000000000000000000000000000..214489a718359c5660105efdbeaf3067d9f388a5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02614.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02614")
+public class BenchmarkTest02614 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02614" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02614"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02614" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            getNextNumber(numGen, randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeBystander";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    void getNextNumber(java.util.Random generator, byte[] barray) {
+        generator.nextBytes(barray);
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02615.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02615.java
new file mode 100644
index 0000000000000000000000000000000000000000..2a1f92d1359e6324ff06bf1a5e139430a20242ec
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02615.java	
@@ -0,0 +1,119 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02615")
+public class BenchmarkTest02615 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02615" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02615"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02615" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02616.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02616.java
new file mode 100644
index 0000000000000000000000000000000000000000..abbd1eeb0f99a1ef3e364d60a0336b54f24944c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02616.java	
@@ -0,0 +1,131 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02616")
+public class BenchmarkTest02616 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02616" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02616"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02616" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Random numGen = java.security.SecureRandom.getInstance("SHA1PRNG");
+            double rand = getNextNumber(numGen);
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonatella";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    double getNextNumber(java.util.Random generator) {
+        return generator.nextDouble();
+    }
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02617.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02617.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a2ee1fb026f65c6dee3dfc32ad909fbde40d522
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02617.java	
@@ -0,0 +1,145 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02617")
+public class BenchmarkTest02617 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02617" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02617"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02617" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.SecureRandom secureRandomGenerator =
+                    java.security.SecureRandom.getInstance("SHA1PRNG");
+
+            // Get 40 random bytes
+            byte[] randomBytes = new byte[40];
+            secureRandomGenerator.nextBytes(randomBytes);
+
+            String rememberMeKey =
+                    org.owasp.esapi.ESAPI.encoder().encodeForBase64(randomBytes, true);
+
+            String user = "SafeByron";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextBytes() - TestCase");
+            throw new ServletException(e);
+        } finally {
+            response.getWriter()
+                    .println(
+                            "Randomness Test java.security.SecureRandom.nextBytes(byte[]) executed");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a80801 = param; // assign
+        StringBuilder b80801 = new StringBuilder(a80801); // stick in stringbuilder
+        b80801.append(" SafeStuff"); // append some safe content
+        b80801.replace(
+                b80801.length() - "Chars".length(),
+                b80801.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map80801 = new java.util.HashMap<String, Object>();
+        map80801.put("key80801", b80801.toString()); // put in a collection
+        String c80801 = (String) map80801.get("key80801"); // get it back out
+        String d80801 = c80801.substring(0, c80801.length() - 1); // extract most of it
+        String e80801 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d80801.getBytes()))); // B64 encode and decode it
+        String f80801 = e80801.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f80801); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02618.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02618.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ffa95e88aa2c86bf3ef75e5cf6f5f18692a6925
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02618.java	
@@ -0,0 +1,124 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02618")
+public class BenchmarkTest02618 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02618" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02618"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02618" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02619.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02619.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b383641bf30835a88f9e3b7408ba46ebaea8017
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02619.java	
@@ -0,0 +1,136 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02619")
+public class BenchmarkTest02619 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02619" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02619"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02619" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02620.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02620.java
new file mode 100644
index 0000000000000000000000000000000000000000..b0f87a72f6062979fd2e84e6c35e3f4f3f14ce5d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02620.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02620")
+public class BenchmarkTest02620 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02620" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02620"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02620" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            int randNumber = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt(99);
+            String rememberMeKey = Integer.toString(randNumber);
+
+            String user = "SafeInga";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt(int) - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt(int) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz33222 = new StringBuilder(param);
+            bar = sbxyz33222.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02621.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02621.java
new file mode 100644
index 0000000000000000000000000000000000000000..4dedd9141ab4de958cc16c6ee9ad877720fb4589
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02621.java	
@@ -0,0 +1,120 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02621")
+public class BenchmarkTest02621 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02621" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02621"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02621" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz33448 = new StringBuilder(param);
+            bar = sbxyz33448.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02622.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02622.java
new file mode 100644
index 0000000000000000000000000000000000000000..e7eb5cb301803778597c28b99c8dde6f2451e7d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02622.java	
@@ -0,0 +1,72 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02622")
+public class BenchmarkTest02622 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02622" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02622"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02622" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String^,java.lang.Object)
+        request.getSession().setAttribute(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: '10340' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz66849 = new StringBuilder(param);
+        String bar = sbxyz66849.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02623.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02623.java
new file mode 100644
index 0000000000000000000000000000000000000000..0047241bd6caf88838968875cf222caae234c319
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02623.java	
@@ -0,0 +1,71 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02623")
+public class BenchmarkTest02623 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02623" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02623"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02623" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02624.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02624.java
new file mode 100644
index 0000000000000000000000000000000000000000..a86340ed2dbcc4e60e06077a7a05fe82fa8a6e9b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02624.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02624")
+public class BenchmarkTest02624 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02624" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02624"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02624" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map3141 = new java.util.HashMap<String, Object>();
+        map3141.put("keyA-3141", "a-Value"); // put some stuff in the collection
+        map3141.put("keyB-3141", param); // put it in a collection
+        map3141.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map3141.get("keyB-3141"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02625.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02625.java
new file mode 100644
index 0000000000000000000000000000000000000000..72361684b470d1bc631dcf560ac0af147c900133
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02625.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02625")
+public class BenchmarkTest02625 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02625" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02625"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02625" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map82391 = new java.util.HashMap<String, Object>();
+        map82391.put("keyA-82391", "a-Value"); // put some stuff in the collection
+        map82391.put("keyB-82391", param); // put it in a collection
+        map82391.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map82391.get("keyB-82391"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02626.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02626.java
new file mode 100644
index 0000000000000000000000000000000000000000..68dc5b3ba4cf751071d17ba2cfd735d010ae6b0b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02626.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02626")
+public class BenchmarkTest02626 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02626" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02626"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02626" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement = connection.prepareCall(sql);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02627.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02627.java
new file mode 100644
index 0000000000000000000000000000000000000000..b416e23415261bebcf1a314441e5331dbdc0749e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02627.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02627")
+public class BenchmarkTest02627 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02627" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02627"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02627" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02628.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02628.java
new file mode 100644
index 0000000000000000000000000000000000000000..f02f8a2d830fdf69ddf83163831b5dbe79b2f6ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02628.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02628")
+public class BenchmarkTest02628 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02628" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02628"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02628" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map23653 = new java.util.HashMap<String, Object>();
+        map23653.put("keyA-23653", "a-Value"); // put some stuff in the collection
+        map23653.put("keyB-23653", param); // put it in a collection
+        map23653.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map23653.get("keyB-23653"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02629.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02629.java
new file mode 100644
index 0000000000000000000000000000000000000000..2044fc44e59255ba41d8e7dca1999f056daa6b0d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02629.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02629")
+public class BenchmarkTest02629 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02629" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02629"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02629" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02630.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02630.java
new file mode 100644
index 0000000000000000000000000000000000000000..c8b8732facc510e5807dbad336258fec718d3d49
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02630.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02630")
+public class BenchmarkTest02630 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02630" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02630"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02630" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "{call " + bar + "}";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.CallableStatement statement =
+                    connection.prepareCall(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            java.sql.ResultSet rs = statement.executeQuery();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02631.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02631.java
new file mode 100644
index 0000000000000000000000000000000000000000..ec5e798f48b00658621f0a0f8a94e6e89b8b7002
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02631.java	
@@ -0,0 +1,83 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02631")
+public class BenchmarkTest02631 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02631" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02631"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02631" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02632.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02632.java
new file mode 100644
index 0000000000000000000000000000000000000000..eaf0bcc9f7ddc29b1d4c301fad1f3ff8fc5fcb69
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02632.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02632")
+public class BenchmarkTest02632 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02632" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02632"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02632" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02633.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02633.java
new file mode 100644
index 0000000000000000000000000000000000000000..1345f6a202534e6397667fbdc2af51fe0f6483ad
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02633.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02633")
+public class BenchmarkTest02633 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02633" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02633"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02633" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a12213 = param; // assign
+        StringBuilder b12213 = new StringBuilder(a12213); // stick in stringbuilder
+        b12213.append(" SafeStuff"); // append some safe content
+        b12213.replace(
+                b12213.length() - "Chars".length(),
+                b12213.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map12213 = new java.util.HashMap<String, Object>();
+        map12213.put("key12213", b12213.toString()); // put in a collection
+        String c12213 = (String) map12213.get("key12213"); // get it back out
+        String d12213 = c12213.substring(0, c12213.length() - 1); // extract most of it
+        String e12213 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d12213.getBytes()))); // B64 encode and decode it
+        String f12213 = e12213.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g12213 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g12213); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02634.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02634.java
new file mode 100644
index 0000000000000000000000000000000000000000..d12918bd557fc2b5e5ed0da024315f0cb73ec36c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02634.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02634")
+public class BenchmarkTest02634 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02634" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02634"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02634" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02635.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02635.java
new file mode 100644
index 0000000000000000000000000000000000000000..cb6301558ee503baed671e9a6b9c0e11027e8964
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02635.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02635")
+public class BenchmarkTest02635 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02635" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02635"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02635" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02636.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02636.java
new file mode 100644
index 0000000000000000000000000000000000000000..26dfc16d03947814740896db68eb3c356d5799ec
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02636.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02636")
+public class BenchmarkTest02636 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02636" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02636"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02636" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02637.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02637.java
new file mode 100644
index 0000000000000000000000000000000000000000..330c6364507f86fb24dda2d6c5d232e253bb6051
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02637.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02637")
+public class BenchmarkTest02637 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02637" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02637"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02637" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02638.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02638.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b0da25d6e2207a0363c1fe616bc59f6ae092354
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02638.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02638")
+public class BenchmarkTest02638 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02638" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02638"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02638" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02639.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02639.java
new file mode 100644
index 0000000000000000000000000000000000000000..0a619dbe8cac194b5f53f782f51e967e90e560d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02639.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02639")
+public class BenchmarkTest02639 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02639" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02639"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02639" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a57676 = param; // assign
+        StringBuilder b57676 = new StringBuilder(a57676); // stick in stringbuilder
+        b57676.append(" SafeStuff"); // append some safe content
+        b57676.replace(
+                b57676.length() - "Chars".length(),
+                b57676.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map57676 = new java.util.HashMap<String, Object>();
+        map57676.put("key57676", b57676.toString()); // put in a collection
+        String c57676 = (String) map57676.get("key57676"); // get it back out
+        String d57676 = c57676.substring(0, c57676.length() - 1); // extract most of it
+        String e57676 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d57676.getBytes()))); // B64 encode and decode it
+        String f57676 = e57676.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g57676 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g57676); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02640.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02640.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c19132f67df2e00cc8757d01b473744368fbe51
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02640.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02640")
+public class BenchmarkTest02640 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02640" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02640"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02640" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.execute(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring execute method doesn't return results.");
+
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02641.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02641.java
new file mode 100644
index 0000000000000000000000000000000000000000..0fc1cb5f79a8dd9c2b840ce29ea5a529a01403c5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02641.java	
@@ -0,0 +1,98 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02641")
+public class BenchmarkTest02641 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02641" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02641"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02641" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02642.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02642.java
new file mode 100644
index 0000000000000000000000000000000000000000..7fe692b1c23fe5f62f345f6a62c2fe9010c51251
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02642.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02642")
+public class BenchmarkTest02642 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02642" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02642"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02642" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02643.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02643.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6010f6172c4405fea63fdf3fdd93dd6024cd371
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02643.java	
@@ -0,0 +1,108 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02643")
+public class BenchmarkTest02643 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02643" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02643"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02643" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02644.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02644.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d5624aecc85ee929b9be171e0c362418e461ab8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02644.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02644")
+public class BenchmarkTest02644 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02644" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02644"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02644" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02645.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02645.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d4bbf8d1b21d9201cc2bab15b97e1e17bb26a00
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02645.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02645")
+public class BenchmarkTest02645 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02645" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02645"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02645" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02646.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02646.java
new file mode 100644
index 0000000000000000000000000000000000000000..7610089020d3523b2c89f8b8b0508c5709eb9341
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02646.java	
@@ -0,0 +1,80 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02646")
+public class BenchmarkTest02646 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02646" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02646"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02646" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02647.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02647.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b49f819e924613f8726fdc0443b7dfdd5124333
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02647.java	
@@ -0,0 +1,84 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-05/BenchmarkTest02647")
+public class BenchmarkTest02647 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02647" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02647"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02647" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.addBatch(sql);
+            int[] counts = statement.executeBatch();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(sql, counts, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02648.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02648.java
new file mode 100644
index 0000000000000000000000000000000000000000..64c9222c693e408222591902f40574223e781b1b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02648.java	
@@ -0,0 +1,82 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02648")
+public class BenchmarkTest02648 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02648" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02648"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02648" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map91488 = new java.util.HashMap<String, Object>();
+        map91488.put("keyA-91488", "a_Value"); // put some stuff in the collection
+        map91488.put("keyB-91488", param); // put it in a collection
+        map91488.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map91488.get("keyB-91488"); // get it back out
+        bar = (String) map91488.get("keyA-91488"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02649.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02649.java
new file mode 100644
index 0000000000000000000000000000000000000000..49a4e8e0a8305acb640c6285e40c58cf53025c7d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02649.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02649")
+public class BenchmarkTest02649 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02649" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02649"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02649" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02650.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02650.java
new file mode 100644
index 0000000000000000000000000000000000000000..acded7c711f7231b8f650772601528a5f165eb9f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02650.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02650")
+public class BenchmarkTest02650 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02650" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02650"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02650" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02651.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02651.java
new file mode 100644
index 0000000000000000000000000000000000000000..69e45ca046544af83717090e4b206551d93fea24
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02651.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02651")
+public class BenchmarkTest02651 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02651" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02651"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02651" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02652.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02652.java
new file mode 100644
index 0000000000000000000000000000000000000000..1f39c55326ebfccaa790f6328bcfd76defc8cf9a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02652.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02652")
+public class BenchmarkTest02652 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02652" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02652"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02652" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new String[] {"username", "password"});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a25323 = param; // assign
+        StringBuilder b25323 = new StringBuilder(a25323); // stick in stringbuilder
+        b25323.append(" SafeStuff"); // append some safe content
+        b25323.replace(
+                b25323.length() - "Chars".length(),
+                b25323.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map25323 = new java.util.HashMap<String, Object>();
+        map25323.put("key25323", b25323.toString()); // put in a collection
+        String c25323 = (String) map25323.get("key25323"); // get it back out
+        String d25323 = c25323.substring(0, c25323.length() - 1); // extract most of it
+        String e25323 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d25323.getBytes()))); // B64 encode and decode it
+        String f25323 = e25323.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g25323 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g25323); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02653.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02653.java
new file mode 100644
index 0000000000000000000000000000000000000000..a4dfa5e87845be025995572dda48cf5a8cfce11e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02653.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02653")
+public class BenchmarkTest02653 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02653" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02653"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02653" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            java.sql.ResultSet rs = statement.executeQuery(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(rs, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02654.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02654.java
new file mode 100644
index 0000000000000000000000000000000000000000..28de6dd0120ebe37cbcf2f860c36cccf860af362
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02654.java	
@@ -0,0 +1,86 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02654")
+public class BenchmarkTest02654 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02654" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02654"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02654" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02655.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02655.java
new file mode 100644
index 0000000000000000000000000000000000000000..248f58de9892898d343ba50d0bc87a0750743c42
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02655.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02655")
+public class BenchmarkTest02655 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02655" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02655"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02655" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02656.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02656.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b7c28b501bb863c89e8e49d5412926e42415876
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02656.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02656")
+public class BenchmarkTest02656 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02656" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02656"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02656" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02657.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02657.java
new file mode 100644
index 0000000000000000000000000000000000000000..cc0a339a0b547e2a2ff0b931d4d07e086a84af4b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02657.java	
@@ -0,0 +1,81 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02657")
+public class BenchmarkTest02657 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        String queryString = request.getQueryString();
+        String paramval = "BenchmarkTest02657" + "=";
+        int paramLoc = -1;
+        if (queryString != null) paramLoc = queryString.indexOf(paramval);
+        if (paramLoc == -1) {
+            response.getWriter()
+                    .println(
+                            "getQueryString() couldn't find expected parameter '"
+                                    + "BenchmarkTest02657"
+                                    + "' in query string.");
+            return;
+        }
+
+        String param =
+                queryString.substring(
+                        paramLoc
+                                + paramval
+                                        .length()); // 1st assume "BenchmarkTest02657" param is last
+        // parameter in query string.
+        // And then check to see if its in the middle of the query string and if so, trim off what
+        // comes after.
+        int ampersandLoc = queryString.indexOf("&", paramLoc);
+        if (ampersandLoc != -1) {
+            param = queryString.substring(paramLoc + paramval.length(), ampersandLoc);
+        }
+        param = java.net.URLDecoder.decode(param, "UTF-8");
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02658.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02658.java
new file mode 100644
index 0000000000000000000000000000000000000000..9641d652b7939c191f0f810cc25f9964bbf8086f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02658.java	
@@ -0,0 +1,144 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-03/BenchmarkTest02658")
+public class BenchmarkTest02658 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02658");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "DES/CBC/PKCS5PADDING", java.security.Security.getProvider("SunJCE"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println(
+                        "Crypto Test javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02659.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02659.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9915b0d6fa257bd54357478a0160472f066a2cc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02659.java	
@@ -0,0 +1,140 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-03/BenchmarkTest02659")
+public class BenchmarkTest02659 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02659");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // AES/GCM example from:
+        // https://javainterviewpoint.com/java-aes-256-gcm-encryption-and-decryption/
+        // 16-byte initialization vector
+        //	    byte[] iv = {
+        //	    	(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //	    	(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3,
+        //	    	(byte)0xF3, (byte)0x3C, (byte)0x23, (byte)0xB9,
+        //	    	(byte)0x9E, (byte)0xC5, (byte)0x77, (byte)0x0B033
+        //	    };
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(16);
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES/GCM/NOPADDING");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            javax.crypto.spec.GCMParameterSpec paramSpec =
+                    new javax.crypto.spec.GCMParameterSpec(16 * 8, iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.NoSuchPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.IllegalBlockSizeException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (javax.crypto.BadPaddingException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        } catch (java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Crypto Test javax.crypto.Cipher.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02660.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02660.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee435def605fadb311b392b99c5a60b1310cf19b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02660.java	
@@ -0,0 +1,129 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-03/BenchmarkTest02660")
+public class BenchmarkTest02660 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02660");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a97788 = param; // assign
+        StringBuilder b97788 = new StringBuilder(a97788); // stick in stringbuilder
+        b97788.append(" SafeStuff"); // append some safe content
+        b97788.replace(
+                b97788.length() - "Chars".length(),
+                b97788.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map97788 = new java.util.HashMap<String, Object>();
+        map97788.put("key97788", b97788.toString()); // put in a collection
+        String c97788 = (String) map97788.get("key97788"); // get it back out
+        String d97788 = c97788.substring(0, c97788.length() - 1); // extract most of it
+        String e97788 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d97788.getBytes()))); // B64 encode and decode it
+        String f97788 = e97788.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f97788); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02661.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02661.java
new file mode 100644
index 0000000000000000000000000000000000000000..d9b6309bc3e31f4642fcf048b0ea141a519e78f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02661.java	
@@ -0,0 +1,112 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-03/BenchmarkTest02661")
+public class BenchmarkTest02661 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02661");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+        // 8-byte initialization vector
+        //		byte[] iv = {
+        //			(byte)0xB2, (byte)0x12, (byte)0xD5, (byte)0xB2,
+        //			(byte)0x44, (byte)0x21, (byte)0xC3, (byte)0xC3033
+        //		};
+        java.security.SecureRandom random = new java.security.SecureRandom();
+        byte[] iv = random.generateSeed(8); // DES requires 8 byte keys
+
+        try {
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("DES/CBC/PKCS5Padding");
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            java.security.spec.AlgorithmParameterSpec paramSpec =
+                    new javax.crypto.spec.IvParameterSpec(iv);
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key, paramSpec);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException
+                | java.security.InvalidAlgorithmParameterException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02662.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02662.java
new file mode 100644
index 0000000000000000000000000000000000000000..ee62e34707f8698ed001792f08dddd467dbbecd3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02662.java	
@@ -0,0 +1,102 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-03/BenchmarkTest02662")
+public class BenchmarkTest02662 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02662");
+
+        String bar = doSomething(request, param);
+
+        // Code based on example from:
+        // http://examples.javacodegeeks.com/core-java/crypto/encrypt-decrypt-file-stream-with-des/
+
+        try {
+            javax.crypto.Cipher c =
+                    javax.crypto.Cipher.getInstance(
+                            "AES/CCM/NoPadding", java.security.Security.getProvider("BC"));
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("AES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) bar = param.split(" ")[0];
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02663.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02663.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b04ca4d1f06a94e5b8c0e180fd313683077b526
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02663.java	
@@ -0,0 +1,100 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/crypto-03/BenchmarkTest02663")
+public class BenchmarkTest02663 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02663");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("cryptoAlg1", "DESede/ECB/PKCS5Padding");
+            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance(algorithm);
+
+            // Prepare the cipher to encrypt
+            javax.crypto.SecretKey key = javax.crypto.KeyGenerator.getInstance("DES").generateKey();
+            c.init(javax.crypto.Cipher.ENCRYPT_MODE, key);
+
+            // encrypt and store the results
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            byte[] result = c.doFinal(input);
+
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "secret_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value: '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' encrypted and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException
+                | javax.crypto.NoSuchPaddingException
+                | javax.crypto.IllegalBlockSizeException
+                | javax.crypto.BadPaddingException
+                | java.security.InvalidKeyException e) {
+            response.getWriter()
+                    .println(
+                            "Problem executing crypto - javax.crypto.Cipher.getInstance(java.lang.String,java.security.Provider) Test Case");
+            e.printStackTrace(response.getWriter());
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02664.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02664.java
new file mode 100644
index 0000000000000000000000000000000000000000..4156b8bf78e1f77defd952a31c826d6268796e5a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02664.java	
@@ -0,0 +1,74 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02664")
+public class BenchmarkTest02664 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02664");
+
+        String bar = doSomething(request, param);
+
+        java.io.File fileTarget = new java.io.File(bar, "/Test.txt");
+        response.getWriter()
+                .println(
+                        "Access to file: '"
+                                + org.owasp
+                                        .esapi
+                                        .ESAPI
+                                        .encoder()
+                                        .encodeForHTML(fileTarget.toString())
+                                + "' created.");
+        if (fileTarget.exists()) {
+            response.getWriter().println(" And file already exists.");
+        } else {
+            response.getWriter().println(" But file doesn't exist yet.");
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02665.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02665.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd1a6a99d5d2a2521f921f02002c96d76adaf394
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02665.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02665")
+public class BenchmarkTest02665 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02665");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(new java.io.File(fileName));
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            response.getWriter()
+                    .println(
+                            "Problem getting FileInputStream: "
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(e.getMessage()));
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02666.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02666.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ecad7aca5ad41b3566a33af42cac8ce96f9e80e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02666.java	
@@ -0,0 +1,78 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02666")
+public class BenchmarkTest02666 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02666");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02667.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02667.java
new file mode 100644
index 0000000000000000000000000000000000000000..8feb5d9f8b46923d31d05f8111c6c811401333f2
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02667.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02667")
+public class BenchmarkTest02667 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02667");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileInputStream fis = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+            fis = new java.io.FileInputStream(fileName);
+            byte[] b = new byte[1000];
+            int size = fis.read(b);
+            response.getWriter()
+                    .println(
+                            "The beginning of file: '"
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName)
+                                    + "' is:\n\n");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(new String(b, 0, size)));
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileInputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fis != null) {
+                try {
+                    fis.close();
+                    fis = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02668.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02668.java
new file mode 100644
index 0000000000000000000000000000000000000000..ba75489f9a5a509cf9e4ab40b66e153ba76da77b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02668.java	
@@ -0,0 +1,70 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02668")
+public class BenchmarkTest02668 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02668");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName, false);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map94533 = new java.util.HashMap<String, Object>();
+        map94533.put("keyA-94533", "a-Value"); // put some stuff in the collection
+        map94533.put("keyB-94533", param); // put it in a collection
+        map94533.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map94533.get("keyB-94533"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02669.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02669.java
new file mode 100644
index 0000000000000000000000000000000000000000..9bd1fe71e9eea489e40c32e26ab03fd1517bcf4f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02669.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/pathtraver-03/BenchmarkTest02669")
+public class BenchmarkTest02669 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02669");
+
+        String bar = doSomething(request, param);
+
+        String fileName = null;
+        java.io.FileOutputStream fos = null;
+
+        try {
+            fileName = org.owasp.benchmark.helpers.Utils.TESTFILES_DIR + bar;
+
+            fos = new java.io.FileOutputStream(fileName);
+            response.getWriter()
+                    .println(
+                            "Now ready to write to file: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(fileName));
+
+        } catch (Exception e) {
+            System.out.println("Couldn't open FileOutputStream on file: '" + fileName + "'");
+            //			System.out.println("File exception caught and swallowed: " + e.getMessage());
+        } finally {
+            if (fos != null) {
+                try {
+                    fos.close();
+                    fos = null;
+                } catch (Exception e) {
+                    // we tried...
+                }
+            }
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02670.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02670.java
new file mode 100644
index 0000000000000000000000000000000000000000..223104d7a3da01408c10ff2e886f4fb1e0652beb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02670.java	
@@ -0,0 +1,111 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02670")
+public class BenchmarkTest02670 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02670");
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02671.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02671.java
new file mode 100644
index 0000000000000000000000000000000000000000..1b0f9164978e364703c2b5a13c37786ba66a3049
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02671.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02671")
+public class BenchmarkTest02671 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02671");
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("SHA1", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("SHA1", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map7984 = new java.util.HashMap<String, Object>();
+        map7984.put("keyA-7984", "a-Value"); // put some stuff in the collection
+        map7984.put("keyB-7984", param); // put it in a collection
+        map7984.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map7984.get("keyB-7984"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02672.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02672.java
new file mode 100644
index 0000000000000000000000000000000000000000..b8d9e5128c3ea9afff16d65ad1d45dc210ed1354
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02672.java	
@@ -0,0 +1,107 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02672")
+public class BenchmarkTest02672 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02672");
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map48519 = new java.util.HashMap<String, Object>();
+        map48519.put("keyA-48519", "a_Value"); // put some stuff in the collection
+        map48519.put("keyB-48519", param); // put it in a collection
+        map48519.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map48519.get("keyB-48519"); // get it back out
+        bar = (String) map48519.get("keyA-48519"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02673.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02673.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9da424390883acef9db28a43c7ba90d84d5ccc6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02673.java	
@@ -0,0 +1,105 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02673")
+public class BenchmarkTest02673 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02673");
+
+        String bar = doSomething(request, param);
+
+        java.security.Provider[] provider = java.security.Security.getProviders();
+        java.security.MessageDigest md;
+
+        try {
+            if (provider.length > 1) {
+
+                md = java.security.MessageDigest.getInstance("sha-384", provider[0]);
+            } else {
+                md = java.security.MessageDigest.getInstance("sha-384", "SUN");
+            }
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        } catch (java.security.NoSuchProviderException e) {
+            System.out.println(
+                    "Problem executing hash - TestCase java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider)");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String,java.security.Provider) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz57216 = new StringBuilder(param);
+            bar = sbxyz57216.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02674.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02674.java
new file mode 100644
index 0000000000000000000000000000000000000000..8a28a5cc406c73037c7741e783d3498dac219279
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02674.java	
@@ -0,0 +1,109 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02674")
+public class BenchmarkTest02674 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02674");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a73069 = param; // assign
+        StringBuilder b73069 = new StringBuilder(a73069); // stick in stringbuilder
+        b73069.append(" SafeStuff"); // append some safe content
+        b73069.replace(
+                b73069.length() - "Chars".length(),
+                b73069.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map73069 = new java.util.HashMap<String, Object>();
+        map73069.put("key73069", b73069.toString()); // put in a collection
+        String c73069 = (String) map73069.get("key73069"); // get it back out
+        String d73069 = c73069.substring(0, c73069.length() - 1); // extract most of it
+        String e73069 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d73069.getBytes()))); // B64 encode and decode it
+        String f73069 = e73069.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g73069 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g73069); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02675.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02675.java
new file mode 100644
index 0000000000000000000000000000000000000000..9dd4f1a1dc39665da50969bfa49e731e646bddbb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02675.java	
@@ -0,0 +1,91 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02675")
+public class BenchmarkTest02675 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02675");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02676.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02676.java
new file mode 100644
index 0000000000000000000000000000000000000000..fb52e8c1b1e12be2886611ea89fdd028296df4f7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02676.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02676")
+public class BenchmarkTest02676 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02676");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02677.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02677.java
new file mode 100644
index 0000000000000000000000000000000000000000..7d850ae33fa11eced6ea48ac5038a9ce260759cb
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02677.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02677")
+public class BenchmarkTest02677 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02677");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg1", "SHA512");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz68995 = new StringBuilder(param);
+            bar = sbxyz68995.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02678.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02678.java
new file mode 100644
index 0000000000000000000000000000000000000000..e0493dd851cab2911c7a83f47151b987a3c0120b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02678.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/hash-02/BenchmarkTest02678")
+public class BenchmarkTest02678 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02678");
+
+        String bar = doSomething(request, param);
+
+        try {
+            java.util.Properties benchmarkprops = new java.util.Properties();
+            benchmarkprops.load(
+                    this.getClass().getClassLoader().getResourceAsStream("benchmark.properties"));
+            String algorithm = benchmarkprops.getProperty("hashAlg2", "SHA5");
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance(algorithm);
+            byte[] input = {(byte) '?'};
+            Object inputParam = bar;
+            if (inputParam instanceof String) input = ((String) inputParam).getBytes();
+            if (inputParam instanceof java.io.InputStream) {
+                byte[] strInput = new byte[1000];
+                int i = ((java.io.InputStream) inputParam).read(strInput);
+                if (i == -1) {
+                    response.getWriter()
+                            .println(
+                                    "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                    return;
+                }
+                input = java.util.Arrays.copyOf(strInput, i);
+            }
+            md.update(input);
+
+            byte[] result = md.digest();
+            java.io.File fileTarget =
+                    new java.io.File(
+                            new java.io.File(org.owasp.benchmark.helpers.Utils.TESTFILES_DIR),
+                            "passwordFile.txt");
+            java.io.FileWriter fw =
+                    new java.io.FileWriter(fileTarget, true); // the true will append the new data
+            fw.write(
+                    "hash_value="
+                            + org.owasp.esapi.ESAPI.encoder().encodeForBase64(result, true)
+                            + "\n");
+            fw.close();
+            response.getWriter()
+                    .println(
+                            "Sensitive value '"
+                                    + org.owasp
+                                            .esapi
+                                            .ESAPI
+                                            .encoder()
+                                            .encodeForHTML(new String(input))
+                                    + "' hashed and stored<br/>");
+
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing hash - TestCase");
+            throw new ServletException(e);
+        }
+
+        response.getWriter()
+                .println(
+                        "Hash Test java.security.MessageDigest.getInstance(java.lang.String) executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02679.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02679.java
new file mode 100644
index 0000000000000000000000000000000000000000..3e03984825729d7c45194a9bf43249eae5b075d4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02679.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02679")
+public class BenchmarkTest02679 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02679");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        java.io.PrintWriter out = response.getWriter();
+        out.write("<!DOCTYPE html>\n<html>\n<body>\n<p>");
+        out.format(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+        out.write("\n</p>\n</body>\n</html>");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02680.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02680.java
new file mode 100644
index 0000000000000000000000000000000000000000..6518f5857becf8937ed30f6ea5c0e174be86d32d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02680.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02680")
+public class BenchmarkTest02680 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02680");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02681.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02681.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6f50b4c3b68b7317628cb7e1168ddadde5201b6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02681.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02681")
+public class BenchmarkTest02681 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02681");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().format(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02682.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02682.java
new file mode 100644
index 0000000000000000000000000000000000000000..224bccb236666b9db818a2bfdcaa92b3612648cf
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02682.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02682")
+public class BenchmarkTest02682 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02682");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02683.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02683.java
new file mode 100644
index 0000000000000000000000000000000000000000..8b9b04ee101e0ad14b03a4beeaa607b9f1b3a3f1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02683.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02683")
+public class BenchmarkTest02683 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02683");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a47309 = param; // assign
+        StringBuilder b47309 = new StringBuilder(a47309); // stick in stringbuilder
+        b47309.append(" SafeStuff"); // append some safe content
+        b47309.replace(
+                b47309.length() - "Chars".length(),
+                b47309.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map47309 = new java.util.HashMap<String, Object>();
+        map47309.put("key47309", b47309.toString()); // put in a collection
+        String c47309 = (String) map47309.get("key47309"); // get it back out
+        String d47309 = c47309.substring(0, c47309.length() - 1); // extract most of it
+        String e47309 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d47309.getBytes()))); // B64 encode and decode it
+        String f47309 = e47309.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g47309 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g47309); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02684.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02684.java
new file mode 100644
index 0000000000000000000000000000000000000000..1188f0c7f1c8802c97f29ff54dfb6df261c68ca1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02684.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02684")
+public class BenchmarkTest02684 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02684");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().print(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02685.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02685.java
new file mode 100644
index 0000000000000000000000000000000000000000..9b89622af65b3f58ddc6eab92bf57046d8bf6f90
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02685.java	
@@ -0,0 +1,50 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02685")
+public class BenchmarkTest02685 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02685");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", bar};
+        response.getWriter().printf(java.util.Locale.US, "Formatted like: %1$s and %2$s.", obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02686.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02686.java
new file mode 100644
index 0000000000000000000000000000000000000000..24059e1c5236c6fb97a37f01d38dfb202f25ac89
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02686.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02686")
+public class BenchmarkTest02686 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02686");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map36618 = new java.util.HashMap<String, Object>();
+        map36618.put("keyA-36618", "a_Value"); // put some stuff in the collection
+        map36618.put("keyB-36618", param); // put it in a collection
+        map36618.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map36618.get("keyB-36618"); // get it back out
+        bar = (String) map36618.get("keyA-36618"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02687.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02687.java
new file mode 100644
index 0000000000000000000000000000000000000000..2614d2e39b920d2a7c28855b04482124ef5251db
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02687.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02687")
+public class BenchmarkTest02687 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02687");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(java.util.Locale.US, bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02688.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02688.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bc4b81de72f26a49f5cf464d1e469c518c3e83b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02688.java	
@@ -0,0 +1,43 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02688")
+public class BenchmarkTest02688 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02688");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.apache.commons.lang.StringEscapeUtils.escapeHtml(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02689.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02689.java
new file mode 100644
index 0000000000000000000000000000000000000000..eded8b2da922c02d90d5d3730bcd68426564b472
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02689.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02689")
+public class BenchmarkTest02689 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02689");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02690.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02690.java
new file mode 100644
index 0000000000000000000000000000000000000000..b697693ccfd8e6661c2653b06e6187a7bcff2aff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02690.java	
@@ -0,0 +1,62 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02690")
+public class BenchmarkTest02690 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02690");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        Object[] obj = {"a", "b"};
+        response.getWriter().printf(bar, obj);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02691.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02691.java
new file mode 100644
index 0000000000000000000000000000000000000000..018a0184648c17b2dfae9b20106a26014513d174
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02691.java	
@@ -0,0 +1,42 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02691")
+public class BenchmarkTest02691 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02691");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02692.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02692.java
new file mode 100644
index 0000000000000000000000000000000000000000..d600ea5320d262518549a943a842d57b142c1f70
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02692.java	
@@ -0,0 +1,47 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02692")
+public class BenchmarkTest02692 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02692");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02693.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02693.java
new file mode 100644
index 0000000000000000000000000000000000000000..a7627779c1d1fe21396202d0308b767820413599
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02693.java	
@@ -0,0 +1,46 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02693")
+public class BenchmarkTest02693 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02693");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz14220 = new StringBuilder(param);
+            bar = sbxyz14220.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02694.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02694.java
new file mode 100644
index 0000000000000000000000000000000000000000..3420d8dae346556a83bc601cd1a9e5f7a2abe9dc
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02694.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02694")
+public class BenchmarkTest02694 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02694");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().println(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02695.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02695.java
new file mode 100644
index 0000000000000000000000000000000000000000..eaab5d9c9d30c265cea465c8936a60cbdd89fe6a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02695.java	
@@ -0,0 +1,52 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02695")
+public class BenchmarkTest02695 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02695");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar.toCharArray());
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02696.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02696.java
new file mode 100644
index 0000000000000000000000000000000000000000..4abf3a488a2e85a59375039eddb051197bebf2ae
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02696.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02696")
+public class BenchmarkTest02696 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02696");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write(bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02697.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02697.java
new file mode 100644
index 0000000000000000000000000000000000000000..166296d3d571daaddb4e71899dc88846e3c80cc7
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02697.java	
@@ -0,0 +1,69 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02697")
+public class BenchmarkTest02697 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02697");
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map29916 = new java.util.HashMap<String, Object>();
+        map29916.put("keyA-29916", "a-Value"); // put some stuff in the collection
+        map29916.put("keyB-29916", param); // put it in a collection
+        map29916.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map29916.get("keyB-29916"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02698.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02698.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2659638b0967f6a28d0c5d4135d29c3f5f7b2ac
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02698.java	
@@ -0,0 +1,66 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02698")
+public class BenchmarkTest02698 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02698");
+
+        String bar = doSomething(request, param);
+
+        java.util.List<String> argList = new java.util.ArrayList<String>();
+
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            argList.add("cmd.exe");
+            argList.add("/c");
+        } else {
+            argList.add("sh");
+            argList.add("-c");
+        }
+        argList.add("echo " + bar);
+
+        ProcessBuilder pb = new ProcessBuilder();
+
+        pb.command(argList);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.util.List) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02699.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02699.java
new file mode 100644
index 0000000000000000000000000000000000000000..265389a857ba4ad12ec7ce791a4a842e3299fb2f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02699.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02699")
+public class BenchmarkTest02699 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02699");
+
+        String bar = doSomething(request, param);
+
+        String a1 = "";
+        String a2 = "";
+        String osName = System.getProperty("os.name");
+        if (osName.indexOf("Windows") != -1) {
+            a1 = "cmd.exe";
+            a2 = "/c";
+        } else {
+            a1 = "sh";
+            a2 = "-c";
+        }
+        String[] args = {a1, a2, "echo " + bar};
+
+        ProcessBuilder pb = new ProcessBuilder(args);
+
+        try {
+            Process p = pb.start();
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println(
+                    "Problem executing cmdi - java.lang.ProcessBuilder(java.lang.String[]) Test Case");
+            throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02700.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02700.java
new file mode 100644
index 0000000000000000000000000000000000000000..c18b332e22baeecc4b9c707991bd4581913497c4
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02700.java	
@@ -0,0 +1,96 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02700")
+public class BenchmarkTest02700 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02700");
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02701.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02701.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e1cd2cb945a7d07f1c2dbe1a073cbed49f79de1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02701.java	
@@ -0,0 +1,90 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02701")
+public class BenchmarkTest02701 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02701");
+
+        String bar = doSomething(request, param);
+
+        byte[] bytes = new byte[10];
+        new java.util.Random().nextBytes(bytes);
+        String rememberMeKey = org.owasp.esapi.ESAPI.encoder().encodeForBase64(bytes, true);
+
+        String user = "Byron";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextBytes() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz86795 = new StringBuilder(param);
+        String bar = sbxyz86795.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02702.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02702.java
new file mode 100644
index 0000000000000000000000000000000000000000..890c6d0f17e675a8c87fc97311e0002cbd29a85e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02702.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-05/BenchmarkTest02702")
+public class BenchmarkTest02702 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02702");
+
+        String bar = doSomething(request, param);
+
+        double value = new java.util.Random().nextDouble();
+        String rememberMeKey = Double.toString(value).substring(2); // Trim off the 0. at the front.
+
+        String user = "Donna";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02703.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02703.java
new file mode 100644
index 0000000000000000000000000000000000000000..e6f75548a001ec0ab8633bc6ce0aa226135c378d
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02703.java	
@@ -0,0 +1,89 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02703")
+public class BenchmarkTest02703 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02703");
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz50196 = new StringBuilder(param);
+        String bar = sbxyz50196.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02704.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02704.java
new file mode 100644
index 0000000000000000000000000000000000000000..f10b28dfafdf82f12144a02dfa9e24c7a252392f
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02704.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02704")
+public class BenchmarkTest02704 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02704");
+
+        String bar = doSomething(request, param);
+
+        float rand = new java.util.Random().nextFloat();
+        String rememberMeKey = Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+        String user = "Floyd";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setDomain(new java.net.URL(request.getRequestURL().toString()).getHost());
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz82472 = new StringBuilder(param);
+            bar = sbxyz82472.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02705.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02705.java
new file mode 100644
index 0000000000000000000000000000000000000000..c785f2bbff4315e9503caac2f0cf67c0783b454c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02705.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02705")
+public class BenchmarkTest02705 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02705");
+
+        String bar = doSomething(request, param);
+
+        double stuff = new java.util.Random().nextGaussian();
+        String rememberMeKey = Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+        String user = "Gayle";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter()
+                .println("Weak Randomness Test java.util.Random.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            StringBuilder sbxyz10228 = new StringBuilder(param);
+            bar = sbxyz10228.replace(param.length() - "Z".length(), param.length(), "Z").toString();
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02706.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02706.java
new file mode 100644
index 0000000000000000000000000000000000000000..17d2c5f2f0c027df392eb370f39f35a11ac77f80
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02706.java	
@@ -0,0 +1,94 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02706")
+public class BenchmarkTest02706 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02706");
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            bar =
+                    new String(
+                            org.apache.commons.codec.binary.Base64.decodeBase64(
+                                    org.apache.commons.codec.binary.Base64.encodeBase64(
+                                            param.getBytes())));
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02707.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02707.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb535d74bc8d6de3c003a0755a8cb62623368831
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02707.java	
@@ -0,0 +1,92 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02707")
+public class BenchmarkTest02707 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02707");
+
+        String bar = doSomething(request, param);
+
+        int r = new java.util.Random().nextInt();
+        String rememberMeKey = Integer.toString(r);
+
+        String user = "Ingrid";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02708.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02708.java
new file mode 100644
index 0000000000000000000000000000000000000000..075ae370fa7aaa401d2935f281d338414712589c
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02708.java	
@@ -0,0 +1,88 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02708")
+public class BenchmarkTest02708 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02708");
+
+        String bar = doSomething(request, param);
+
+        long l = new java.util.Random().nextLong();
+        String rememberMeKey = Long.toString(l);
+
+        String user = "Logan";
+        String fullClassName = this.getClass().getName();
+        String testCaseNumber =
+                fullClassName.substring(
+                        fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+        user += testCaseNumber;
+
+        String cookieName = "rememberMe" + testCaseNumber;
+
+        boolean foundUser = false;
+        javax.servlet.http.Cookie[] cookies = request.getCookies();
+        if (cookies != null) {
+            for (int i = 0; !foundUser && i < cookies.length; i++) {
+                javax.servlet.http.Cookie cookie = cookies[i];
+                if (cookieName.equals(cookie.getName())) {
+                    if (cookie.getValue().equals(request.getSession().getAttribute(cookieName))) {
+                        foundUser = true;
+                    }
+                }
+            }
+        }
+
+        if (foundUser) {
+            response.getWriter().println("Welcome back: " + user + "<br/>");
+
+        } else {
+            javax.servlet.http.Cookie rememberMe =
+                    new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+            rememberMe.setSecure(true);
+            rememberMe.setHttpOnly(true);
+            rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+            // e.g., /benchmark/sql-01/BenchmarkTest01001
+            request.getSession().setAttribute(cookieName, rememberMeKey);
+            response.addCookie(rememberMe);
+            response.getWriter()
+                    .println(
+                            user
+                                    + " has been remembered with cookie: "
+                                    + rememberMe.getName()
+                                    + " whose value is: "
+                                    + rememberMe.getValue()
+                                    + "<br/>");
+        }
+
+        response.getWriter().println("Weak Randomness Test java.util.Random.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02709.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02709.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a53d7297ff162558886e3f9e69ab8f65f69ea86
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02709.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02709")
+public class BenchmarkTest02709 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02709");
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns param to bar on false condition
+        int num = 106;
+
+        bar = (7 * 42) - num > 200 ? "This should never happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02710.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02710.java
new file mode 100644
index 0000000000000000000000000000000000000000..b757df255d6acb395c953e47b1f5a9c4b93595ee
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02710.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02710")
+public class BenchmarkTest02710 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02710");
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(false);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: false");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02711.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02711.java
new file mode 100644
index 0000000000000000000000000000000000000000..97a14eaa4972fc390ba277259e7699d757d34150
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02711.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/securecookie-00/BenchmarkTest02711")
+public class BenchmarkTest02711 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02711");
+
+        String bar = doSomething(request, param);
+
+        byte[] input = new byte[1000];
+        String str = "?";
+        Object inputParam = param;
+        if (inputParam instanceof String) str = ((String) inputParam);
+        if (inputParam instanceof java.io.InputStream) {
+            int i = ((java.io.InputStream) inputParam).read(input);
+            if (i == -1) {
+                response.getWriter()
+                        .println(
+                                "This input source requires a POST, not a GET. Incompatible UI for the InputStream source.");
+                return;
+            }
+            str = new String(input, 0, i);
+        }
+        if ("".equals(str)) str = "No cookie value supplied";
+        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("SomeCookie", str);
+
+        cookie.setSecure(true);
+        cookie.setHttpOnly(true);
+        cookie.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+        // e.g., /benchmark/sql-01/BenchmarkTest01001
+        response.addCookie(cookie);
+
+        response.getWriter()
+                .println(
+                        "Created cookie: 'SomeCookie': with value: '"
+                                + org.owasp.esapi.ESAPI.encoder().encodeForHTML(str)
+                                + "' and secure flag set to: true");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02712.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02712.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f9c3d2441d0f473fb9e765265c8f246bb9b4d39
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02712.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/xss-05/BenchmarkTest02712")
+public class BenchmarkTest02712 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02712");
+
+        String bar = doSomething(request, param);
+
+        response.setHeader("X-XSS-Protection", "0");
+        response.getWriter().write("Parameter value: " + bar);
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map52216 = new java.util.HashMap<String, Object>();
+        map52216.put("keyA-52216", "a_Value"); // put some stuff in the collection
+        map52216.put("keyB-52216", param); // put it in a collection
+        map52216.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map52216.get("keyB-52216"); // get it back out
+        bar = (String) map52216.get("keyA-52216"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02713.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02713.java
new file mode 100644
index 0000000000000000000000000000000000000000..587d1d0378af88995d9a76b9cc12e6d3d825045e
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02713.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02713")
+public class BenchmarkTest02713 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02713");
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] args = {cmd};
+        String[] argsEnv = {bar};
+
+        Runtime r = Runtime.getRuntime();
+
+        try {
+            Process p = r.exec(args, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02714.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02714.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a49014cc95429b3e6e1f81f89bf8d8f4e44a6d0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02714.java	
@@ -0,0 +1,64 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/cmdi-03/BenchmarkTest02714")
+public class BenchmarkTest02714 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02714");
+
+        String bar = doSomething(request, param);
+
+        String cmd =
+                org.owasp.benchmark.helpers.Utils.getInsecureOSCommandString(
+                        this.getClass().getClassLoader());
+        String[] argsEnv = {bar};
+        Runtime r = Runtime.getRuntime();
+        try {
+            Process p = r.exec(cmd, argsEnv, new java.io.File(System.getProperty("user.dir")));
+            org.owasp.benchmark.helpers.Utils.printOSCommandResults(p, response);
+        } catch (IOException e) {
+            System.out.println("Problem executing cmdi - TestCase");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(e.getMessage()));
+            return;
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02715.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02715.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2bc22645d91a5acde1591fed17a062ede23b549
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02715.java	
@@ -0,0 +1,106 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02715")
+public class BenchmarkTest02715 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02715");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextDouble();
+
+            String rememberMeKey =
+                    Double.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeDonna";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextDouble() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextDouble() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02716.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02716.java
new file mode 100644
index 0000000000000000000000000000000000000000..6365e46a1cf915ca47e3010ba121df282271b1a6
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02716.java	
@@ -0,0 +1,115 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02716")
+public class BenchmarkTest02716 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02716");
+
+        String bar = doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a26751 = param; // assign
+        StringBuilder b26751 = new StringBuilder(a26751); // stick in stringbuilder
+        b26751.append(" SafeStuff"); // append some safe content
+        b26751.replace(
+                b26751.length() - "Chars".length(),
+                b26751.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map26751 = new java.util.HashMap<String, Object>();
+        map26751.put("key26751", b26751.toString()); // put in a collection
+        String c26751 = (String) map26751.get("key26751"); // get it back out
+        String d26751 = c26751.substring(0, c26751.length() - 1); // extract most of it
+        String e26751 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d26751.getBytes()))); // B64 encode and decode it
+        String f26751 = e26751.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g26751 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g26751); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02717.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02717.java
new file mode 100644
index 0000000000000000000000000000000000000000..65a0b2014a846840c0c5531a775ad57aef181194
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02717.java	
@@ -0,0 +1,97 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02717")
+public class BenchmarkTest02717 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02717");
+
+        String bar = doSomething(request, param);
+
+        try {
+            float rand = java.security.SecureRandom.getInstance("SHA1PRNG").nextFloat();
+            String rememberMeKey =
+                    Float.toString(rand).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeFloyd";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextFloat() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextFloat() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02718.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02718.java
new file mode 100644
index 0000000000000000000000000000000000000000..c0c096f7330a3ed1cca91d81d8e14daa6f70bb13
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02718.java	
@@ -0,0 +1,114 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02718")
+public class BenchmarkTest02718 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02718");
+
+        String bar = doSomething(request, param);
+
+        try {
+            double stuff = java.security.SecureRandom.getInstance("SHA1PRNG").nextGaussian();
+            String rememberMeKey =
+                    Double.toString(stuff).substring(2); // Trim off the 0. at the front.
+
+            String user = "SafeGayle";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextGaussian() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextGaussian() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a49179 = param; // assign
+        StringBuilder b49179 = new StringBuilder(a49179); // stick in stringbuilder
+        b49179.append(" SafeStuff"); // append some safe content
+        b49179.replace(
+                b49179.length() - "Chars".length(),
+                b49179.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map49179 = new java.util.HashMap<String, Object>();
+        map49179.put("key49179", b49179.toString()); // put in a collection
+        String c49179 = (String) map49179.get("key49179"); // get it back out
+        String d49179 = c49179.substring(0, c49179.length() - 1); // extract most of it
+        String e49179 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d49179.getBytes()))); // B64 encode and decode it
+        String f49179 = e49179.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(f49179); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02719.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02719.java
new file mode 100644
index 0000000000000000000000000000000000000000..bc5898ecc46aebd4c5adb9bdb5eced8b1eeaa8b5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02719.java	
@@ -0,0 +1,99 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02719")
+public class BenchmarkTest02719 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02719");
+
+        String bar = doSomething(request, param);
+
+        try {
+            int r = java.security.SecureRandom.getInstance("SHA1PRNG").nextInt();
+            String rememberMeKey = Integer.toString(r);
+
+            String user = "SafeIngrid";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextInt() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextInt() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map75503 = new java.util.HashMap<String, Object>();
+        map75503.put("keyA-75503", "a_Value"); // put some stuff in the collection
+        map75503.put("keyB-75503", param); // put it in a collection
+        map75503.put("keyC", "another_Value"); // put some stuff in the collection
+        bar = (String) map75503.get("keyB-75503"); // get it back out
+        bar = (String) map75503.get("keyA-75503"); // get safe value back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02720.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02720.java
new file mode 100644
index 0000000000000000000000000000000000000000..55a5593d9c2f042d8edb3d907411e079961f5d3b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02720.java	
@@ -0,0 +1,95 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02720")
+public class BenchmarkTest02720 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02720");
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02721.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02721.java
new file mode 100644
index 0000000000000000000000000000000000000000..3b3a0733e0aa8d43f75d5979e1f48fd150a9cb5b
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02721.java	
@@ -0,0 +1,93 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/weakrand-06/BenchmarkTest02721")
+public class BenchmarkTest02721 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02721");
+
+        String bar = doSomething(request, param);
+
+        try {
+            long l = java.security.SecureRandom.getInstance("SHA1PRNG").nextLong();
+            String rememberMeKey = Long.toString(l);
+
+            String user = "SafeLogan";
+            String fullClassName = this.getClass().getName();
+            String testCaseNumber =
+                    fullClassName.substring(
+                            fullClassName.lastIndexOf('.') + 1 + "BenchmarkTest".length());
+            user += testCaseNumber;
+
+            String cookieName = "rememberMe" + testCaseNumber;
+
+            boolean foundUser = false;
+            javax.servlet.http.Cookie[] cookies = request.getCookies();
+            if (cookies != null) {
+                for (int i = 0; !foundUser && i < cookies.length; i++) {
+                    javax.servlet.http.Cookie cookie = cookies[i];
+                    if (cookieName.equals(cookie.getName())) {
+                        if (cookie.getValue()
+                                .equals(request.getSession().getAttribute(cookieName))) {
+                            foundUser = true;
+                        }
+                    }
+                }
+            }
+
+            if (foundUser) {
+                response.getWriter().println("Welcome back: " + user + "<br/>");
+            } else {
+                javax.servlet.http.Cookie rememberMe =
+                        new javax.servlet.http.Cookie(cookieName, rememberMeKey);
+                rememberMe.setSecure(true);
+                rememberMe.setHttpOnly(true);
+                rememberMe.setPath(request.getRequestURI()); // i.e., set path to JUST this servlet
+                // e.g., /benchmark/sql-01/BenchmarkTest01001
+                request.getSession().setAttribute(cookieName, rememberMeKey);
+                response.addCookie(rememberMe);
+                response.getWriter()
+                        .println(
+                                user
+                                        + " has been remembered with cookie: "
+                                        + rememberMe.getName()
+                                        + " whose value is: "
+                                        + rememberMe.getValue()
+                                        + "<br/>");
+            }
+        } catch (java.security.NoSuchAlgorithmException e) {
+            System.out.println("Problem executing SecureRandom.nextLong() - TestCase");
+            throw new ServletException(e);
+        }
+        response.getWriter()
+                .println("Weak Randomness Test java.security.SecureRandom.nextLong() executed");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.springframework.web.util.HtmlUtils.htmlEscape(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02722.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02722.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e00fc5535141348d48ce5da83b8e55c553b92ca
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02722.java	
@@ -0,0 +1,48 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02722")
+public class BenchmarkTest02722 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02722");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = org.owasp.esapi.ESAPI.encoder().encodeForHTML(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02723.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02723.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2c9ef6464b8691242824865736ace365b67062a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02723.java	
@@ -0,0 +1,49 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02723")
+public class BenchmarkTest02723 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02723");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        StringBuilder sbxyz51151 = new StringBuilder(param);
+        String bar = sbxyz51151.append("_SafeStuff").toString();
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02724.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02724.java
new file mode 100644
index 0000000000000000000000000000000000000000..0d7ffb436d9f44c01fa2b93f62e810131c4aad28
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02724.java	
@@ -0,0 +1,67 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02724")
+public class BenchmarkTest02724 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02724");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.putValue(java.lang.String^,java.lang.Object)
+        request.getSession().putValue(bar, "10340");
+
+        response.getWriter()
+                .println(
+                        "Item: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' with value: 10340 saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(2);
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bobs_your_uncle";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bobs_your_uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02725.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02725.java
new file mode 100644
index 0000000000000000000000000000000000000000..ebfd0bb9104be659214c7ecf8ea44c0664ff20ff
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02725.java	
@@ -0,0 +1,53 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02725")
+public class BenchmarkTest02725 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02725");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple ? condition that assigns constant to bar on true condition
+        int num = 106;
+
+        bar = (7 * 18) + num > 200 ? "This_should_always_happen" : param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02726.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02726.java
new file mode 100644
index 0000000000000000000000000000000000000000..113151674dc330c0ddc294bbf0c360b30fa7c534
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02726.java	
@@ -0,0 +1,51 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/trustbound-01/BenchmarkTest02726")
+public class BenchmarkTest02726 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02726");
+
+        String bar = doSomething(request, param);
+
+        // javax.servlet.http.HttpSession.setAttribute(java.lang.String,java.lang.Object^)
+        request.getSession().setAttribute("userid", bar);
+
+        response.getWriter()
+                .println(
+                        "Item: 'userid' with value: '"
+                                + org.owasp.benchmark.helpers.Utils.encodeForHTML(bar)
+                                + "' saved in session.");
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+        if (param != null && param.length() > 1) {
+            bar = param.substring(0, param.length() - 1);
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02727.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02727.java
new file mode 100644
index 0000000000000000000000000000000000000000..01bef9abf5b34417ff3de06b6635287c19c891d1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02727.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02727")
+public class BenchmarkTest02727 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02727");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, java.sql.Statement.RETURN_GENERATED_KEYS);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02728.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02728.java
new file mode 100644
index 0000000000000000000000000000000000000000..a57e0db9ca426f27c1ad5f8521595473a04359ba
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02728.java	
@@ -0,0 +1,65 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02728")
+public class BenchmarkTest02728 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02728");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(
+                            sql,
+                            java.sql.ResultSet.TYPE_FORWARD_ONLY,
+                            java.sql.ResultSet.CONCUR_READ_ONLY,
+                            java.sql.ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map55235 = new java.util.HashMap<String, Object>();
+        map55235.put("keyA-55235", "a-Value"); // put some stuff in the collection
+        map55235.put("keyB-55235", param); // put it in a collection
+        map55235.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map55235.get("keyB-55235"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02729.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02729.java
new file mode 100644
index 0000000000000000000000000000000000000000..aeb91a31a6347a9793a4dd6061ab1dde9733c2da
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02729.java	
@@ -0,0 +1,61 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02729")
+public class BenchmarkTest02729 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02729");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new int[] {1, 2});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "safe!";
+        java.util.HashMap<String, Object> map87005 = new java.util.HashMap<String, Object>();
+        map87005.put("keyA-87005", "a-Value"); // put some stuff in the collection
+        map87005.put("keyB-87005", param); // put it in a collection
+        map87005.put("keyC", "another-Value"); // put some stuff in the collection
+        bar = (String) map87005.get("keyB-87005"); // get it back out
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02730.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02730.java
new file mode 100644
index 0000000000000000000000000000000000000000..44036b94b13f5cbf026e7ca01bfcb45f3ea432c1
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02730.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02730")
+public class BenchmarkTest02730 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02730");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME=? and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Connection connection =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlConnection();
+            java.sql.PreparedStatement statement =
+                    connection.prepareStatement(sql, new String[] {"Column1", "Column2"});
+            statement.setString(1, "foo");
+            statement.execute();
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        // Chain a bunch of propagators in sequence
+        String a81593 = param; // assign
+        StringBuilder b81593 = new StringBuilder(a81593); // stick in stringbuilder
+        b81593.append(" SafeStuff"); // append some safe content
+        b81593.replace(
+                b81593.length() - "Chars".length(),
+                b81593.length(),
+                "Chars"); // replace some of the end content
+        java.util.HashMap<String, Object> map81593 = new java.util.HashMap<String, Object>();
+        map81593.put("key81593", b81593.toString()); // put in a collection
+        String c81593 = (String) map81593.get("key81593"); // get it back out
+        String d81593 = c81593.substring(0, c81593.length() - 1); // extract most of it
+        String e81593 =
+                new String(
+                        org.apache.commons.codec.binary.Base64.decodeBase64(
+                                org.apache.commons.codec.binary.Base64.encodeBase64(
+                                        d81593.getBytes()))); // B64 encode and decode it
+        String f81593 = e81593.split(" ")[0]; // split it on a space
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String g81593 = "barbarians_at_the_gate"; // This is static so this whole flow is 'safe'
+        String bar = thing.doSomething(g81593); // reflection
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02731.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02731.java
new file mode 100644
index 0000000000000000000000000000000000000000..c6acd60553836422b97ee25231e8856b0f7c8fb8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02731.java	
@@ -0,0 +1,57 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02731")
+public class BenchmarkTest02731 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02731");
+
+        String bar = doSomething(request, param);
+
+        try {
+            String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+            org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.batchUpdate(sql);
+            response.getWriter()
+                    .println(
+                            "No results can be displayed for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql)
+                                    + "<br>"
+                                    + " because the Spring batchUpdate method doesn't return results.");
+            //		System.out.println("no results for query: " + sql + " because the Spring batchUpdate
+            // method doesn't return results.");
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02732.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02732.java
new file mode 100644
index 0000000000000000000000000000000000000000..22f6bfc880f015cee9c4dc46761a3485a7230057
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02732.java	
@@ -0,0 +1,75 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02732")
+public class BenchmarkTest02732 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02732");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<String> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.query(
+                            sql,
+                            new org.springframework.jdbc.core.RowMapper<String>() {
+                                @Override
+                                public String mapRow(java.sql.ResultSet rs, int rowNum)
+                                        throws java.sql.SQLException {
+                                    try {
+                                        return rs.getString("USERNAME");
+                                    } catch (java.sql.SQLException e) {
+                                        if (org.owasp.benchmark.helpers.DatabaseHelper
+                                                .hideSQLErrors) {
+                                            return "Error processing query.";
+                                        } else throw e;
+                                    }
+                                }
+                            });
+            response.getWriter().println("Your results are: ");
+
+            for (String s : results) {
+                response.getWriter()
+                        .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(s) + "<br>");
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02733.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02733.java
new file mode 100644
index 0000000000000000000000000000000000000000..f3e674cfff958a8b04cece883f5fcea5f2b63fd0
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02733.java	
@@ -0,0 +1,76 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02733")
+public class BenchmarkTest02733 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02733");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.List<java.util.Map<String, Object>> list =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForList(sql);
+            response.getWriter().println("Your results are: <br>");
+
+            //		System.out.println("Your results are");
+
+            for (Object o : list) {
+                response.getWriter()
+                        .println(
+                                org.owasp.esapi.ESAPI.encoder().encodeForHTML(o.toString())
+                                        + "<br>");
+                //			System.out.println(o.toString());
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02734.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02734.java
new file mode 100644
index 0000000000000000000000000000000000000000..b48302f9f00b6982e13747ccb7b77d5b64dec9d3
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02734.java	
@@ -0,0 +1,68 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02734")
+public class BenchmarkTest02734 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02734");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02735.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02735.java
new file mode 100644
index 0000000000000000000000000000000000000000..5700909bfa274e1107063af0786bca783842a335
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02735.java	
@@ -0,0 +1,77 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02735")
+public class BenchmarkTest02735 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02735");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            // Long results =
+            // org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForLong(sql);
+            Long results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForObject(
+                            sql, Long.class);
+            response.getWriter().println("Your results are: " + String.valueOf(results));
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+        String guess = "ABC";
+        char switchTarget = guess.charAt(1); // condition 'B', which is safe
+
+        // Simple case statement that assigns param to bar on conditions 'A', 'C', or 'D'
+        switch (switchTarget) {
+            case 'A':
+                bar = param;
+                break;
+            case 'B':
+                bar = "bob";
+                break;
+            case 'C':
+            case 'D':
+                bar = param;
+                break;
+            default:
+                bar = "bob's your uncle";
+                break;
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02736.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02736.java
new file mode 100644
index 0000000000000000000000000000000000000000..afa70d8722dd6ae16de9f26bf7efa53ae0930ab5
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02736.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02736")
+public class BenchmarkTest02736 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02736");
+
+        String bar = doSomething(request, param);
+
+        String sql =
+                "SELECT TOP 1 userid from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            java.util.Map<String, Object> results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForMap(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            response.getWriter()
+                    .println(org.owasp.esapi.ESAPI.encoder().encodeForHTML(results.toString()));
+            //		System.out.println(results.toString());
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        org.owasp.benchmark.helpers.ThingInterface thing =
+                org.owasp.benchmark.helpers.ThingFactory.createThing();
+        String bar = thing.doSomething(param);
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02737.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02737.java
new file mode 100644
index 0000000000000000000000000000000000000000..3258ac7d3851b609768c3b52818b5f74c04d6f9a
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02737.java	
@@ -0,0 +1,73 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02737")
+public class BenchmarkTest02737 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02737");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT  * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+        try {
+            org.springframework.jdbc.support.rowset.SqlRowSet results =
+                    org.owasp.benchmark.helpers.DatabaseHelper.JDBCtemplate.queryForRowSet(sql);
+            response.getWriter().println("Your results are: ");
+
+            //		System.out.println("Your results are");
+            while (results.next()) {
+                response.getWriter()
+                        .println(
+                                org.owasp
+                                                .esapi
+                                                .ESAPI
+                                                .encoder()
+                                                .encodeForHTML(results.getString("USERNAME"))
+                                        + " ");
+                //			System.out.println(results.getString("USERNAME"));
+            }
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            response.getWriter()
+                    .println(
+                            "No results returned for query: "
+                                    + org.owasp.esapi.ESAPI.encoder().encodeForHTML(sql));
+        } catch (org.springframework.dao.DataAccessException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns constant to bar on true condition
+        int num = 86;
+        if ((7 * 42) - num > 200) bar = "This_should_always_happen";
+        else bar = param;
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02738.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02738.java
new file mode 100644
index 0000000000000000000000000000000000000000..41e14c21a81a2074b5cc4b8f79576f9bf1a58d49
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02738.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02738")
+public class BenchmarkTest02738 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02738");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "alsosafe";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(1); // get the last 'safe' value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02739.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02739.java
new file mode 100644
index 0000000000000000000000000000000000000000..fe92bd080d46820ef8bf1edf344ff64080d4eaa8
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02739.java	
@@ -0,0 +1,63 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02739")
+public class BenchmarkTest02739 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02739");
+
+        String bar = doSomething(request, param);
+
+        String sql = "SELECT * from USERS where USERNAME='foo' and PASSWORD='" + bar + "'";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            statement.execute(sql, new int[] {1, 2});
+            org.owasp.benchmark.helpers.DatabaseHelper.printResults(statement, sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar = "";
+        if (param != null) {
+            java.util.List<String> valuesList = new java.util.ArrayList<String>();
+            valuesList.add("safe");
+            valuesList.add(param);
+            valuesList.add("moresafe");
+
+            valuesList.remove(0); // remove the 1st safe value
+
+            bar = valuesList.get(0); // get the param value
+        }
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02740.java b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02740.java
new file mode 100644
index 0000000000000000000000000000000000000000..dfb76990d7f264460f13293a3d0256361ef45736
--- /dev/null
+++ b/OWASP DATASET CLEANED/cleaned_Test_Cases/BenchmarkTest02740.java	
@@ -0,0 +1,58 @@
+
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+@WebServlet(value = "/sqli-06/BenchmarkTest02740")
+public class BenchmarkTest02740 extends HttpServlet {
+
+    private static final long serialVersionUID = 1L;
+
+    @Override
+    public void doGet(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        doPost(request, response);
+    }
+
+    @Override
+    public void doPost(HttpServletRequest request, HttpServletResponse response)
+            throws ServletException, IOException {
+        response.setContentType("text/html;charset=UTF-8");
+
+        org.owasp.benchmark.helpers.SeparateClassRequest scr =
+                new org.owasp.benchmark.helpers.SeparateClassRequest(request);
+        String param = scr.getTheValue("BenchmarkTest02740");
+
+        String bar = doSomething(request, param);
+
+        String sql = "INSERT INTO users (username, password) VALUES ('foo','" + bar + "')";
+
+        try {
+            java.sql.Statement statement =
+                    org.owasp.benchmark.helpers.DatabaseHelper.getSqlStatement();
+            int count = statement.executeUpdate(sql);
+            org.owasp.benchmark.helpers.DatabaseHelper.outputUpdateComplete(sql, response);
+        } catch (java.sql.SQLException e) {
+            if (org.owasp.benchmark.helpers.DatabaseHelper.hideSQLErrors) {
+                response.getWriter().println("Error processing request.");
+                return;
+            } else throw new ServletException(e);
+        }
+    } // end doPost
+
+    private static String doSomething(HttpServletRequest request, String param)
+            throws ServletException, IOException {
+
+        String bar;
+
+        // Simple if statement that assigns param to bar on true condition
+        int num = 196;
+        if ((500 / 42) + num > 200) bar = param;
+        else bar = "This should never happen";
+
+        return bar;
+    }
+}
diff --git a/OWASP DATASET CLEANED/expectedresults/expectedresults-1.2-enriched.csv b/OWASP DATASET CLEANED/expectedresults/expectedresults-1.2-enriched.csv
new file mode 100644
index 0000000000000000000000000000000000000000..6d58200cd236d475689c4a4e726a75beaeced68e
--- /dev/null
+++ b/OWASP DATASET CLEANED/expectedresults/expectedresults-1.2-enriched.csv	
@@ -0,0 +1,2741 @@
+# test name,category,real vulnerability,cwe,Benchmark version: 1.2,2016-06-1,Full Category Name
+BenchmarkTest00001,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00002,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00003,hash,True,328,,,Weak Hashing
+BenchmarkTest00004,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00005,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00006,cmdi,True,78,,,Command Injection
+BenchmarkTest00007,cmdi,True,78,,,Command Injection
+BenchmarkTest00008,sqli,True,89,,,SQL Injection
+BenchmarkTest00009,hash,False,328,,,Weak Hashing
+BenchmarkTest00010,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00011,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00012,ldapi,True,90,,,LDAP Injection
+BenchmarkTest00013,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00014,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00015,cmdi,True,78,,,Command Injection
+BenchmarkTest00016,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest00017,cmdi,True,78,,,Command Injection
+BenchmarkTest00018,sqli,True,89,,,SQL Injection
+BenchmarkTest00019,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00020,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00021,ldapi,True,90,,,LDAP Injection
+BenchmarkTest00022,hash,False,328,,,Weak Hashing
+BenchmarkTest00023,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00024,sqli,True,89,,,SQL Injection
+BenchmarkTest00025,sqli,True,89,,,SQL Injection
+BenchmarkTest00026,sqli,True,89,,,SQL Injection
+BenchmarkTest00027,sqli,True,89,,,SQL Injection
+BenchmarkTest00028,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00029,hash,True,328,,,Weak Hashing
+BenchmarkTest00030,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00031,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00032,sqli,True,89,,,SQL Injection
+BenchmarkTest00033,sqli,True,89,,,SQL Injection
+BenchmarkTest00034,sqli,True,89,,,SQL Injection
+BenchmarkTest00035,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00036,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00037,sqli,True,89,,,SQL Injection
+BenchmarkTest00038,sqli,True,89,,,SQL Injection
+BenchmarkTest00039,sqli,True,89,,,SQL Injection
+BenchmarkTest00040,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00041,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00042,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00043,sqli,True,89,,,SQL Injection
+BenchmarkTest00044,ldapi,True,90,,,LDAP Injection
+BenchmarkTest00045,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00046,hash,True,328,,,Weak Hashing
+BenchmarkTest00047,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00048,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00049,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00050,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00051,cmdi,False,78,,,Command Injection
+BenchmarkTest00052,sqli,False,89,,,SQL Injection
+BenchmarkTest00053,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00054,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00055,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00056,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00057,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00058,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00059,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00060,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00061,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00062,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00063,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00064,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00065,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00066,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00067,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00068,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00069,hash,False,328,,,Weak Hashing
+BenchmarkTest00070,hash,True,328,,,Weak Hashing
+BenchmarkTest00071,hash,True,328,,,Weak Hashing
+BenchmarkTest00072,hash,False,328,,,Weak Hashing
+BenchmarkTest00073,hash,True,328,,,Weak Hashing
+BenchmarkTest00074,hash,True,328,,,Weak Hashing
+BenchmarkTest00075,hash,False,328,,,Weak Hashing
+BenchmarkTest00076,hash,False,328,,,Weak Hashing
+BenchmarkTest00077,cmdi,True,78,,,Command Injection
+BenchmarkTest00078,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00079,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00080,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00081,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00082,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00083,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00084,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00085,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00086,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00087,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00088,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest00089,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest00090,cmdi,False,78,,,Command Injection
+BenchmarkTest00091,cmdi,True,78,,,Command Injection
+BenchmarkTest00092,cmdi,True,78,,,Command Injection
+BenchmarkTest00093,cmdi,False,78,,,Command Injection
+BenchmarkTest00094,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00095,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00096,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00097,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00098,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00099,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00100,sqli,True,89,,,SQL Injection
+BenchmarkTest00101,sqli,True,89,,,SQL Injection
+BenchmarkTest00102,sqli,True,89,,,SQL Injection
+BenchmarkTest00103,sqli,True,89,,,SQL Injection
+BenchmarkTest00104,sqli,False,89,,,SQL Injection
+BenchmarkTest00105,sqli,False,89,,,SQL Injection
+BenchmarkTest00106,sqli,True,89,,,SQL Injection
+BenchmarkTest00107,sqli,False,89,,,SQL Injection
+BenchmarkTest00108,sqli,True,89,,,SQL Injection
+BenchmarkTest00109,sqli,True,89,,,SQL Injection
+BenchmarkTest00110,sqli,False,89,,,SQL Injection
+BenchmarkTest00111,sqli,True,89,,,SQL Injection
+BenchmarkTest00112,sqli,True,89,,,SQL Injection
+BenchmarkTest00113,sqli,False,89,,,SQL Injection
+BenchmarkTest00114,sqli,False,89,,,SQL Injection
+BenchmarkTest00115,sqli,True,89,,,SQL Injection
+BenchmarkTest00116,xpathi,False,643,,,XPATH Injection
+BenchmarkTest00117,xpathi,False,643,,,XPATH Injection
+BenchmarkTest00118,xpathi,False,643,,,XPATH Injection
+BenchmarkTest00119,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00120,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00121,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00122,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00123,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00124,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00125,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00126,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00127,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00128,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00129,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00130,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00131,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00132,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00133,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00134,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00135,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00136,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00137,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00138,ldapi,False,90,,,LDAP Injection
+BenchmarkTest00139,ldapi,False,90,,,LDAP Injection
+BenchmarkTest00140,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00141,hash,True,328,,,Weak Hashing
+BenchmarkTest00142,hash,False,328,,,Weak Hashing
+BenchmarkTest00143,hash,True,328,,,Weak Hashing
+BenchmarkTest00144,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00145,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00146,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00147,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00148,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00149,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00150,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00151,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00152,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00153,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00154,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00155,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00156,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00157,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00158,cmdi,False,78,,,Command Injection
+BenchmarkTest00159,cmdi,True,78,,,Command Injection
+BenchmarkTest00160,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00161,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00162,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00163,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00164,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00165,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00166,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00167,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00168,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00169,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00170,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00171,cmdi,False,78,,,Command Injection
+BenchmarkTest00172,cmdi,True,78,,,Command Injection
+BenchmarkTest00173,cmdi,True,78,,,Command Injection
+BenchmarkTest00174,cmdi,True,78,,,Command Injection
+BenchmarkTest00175,cmdi,False,78,,,Command Injection
+BenchmarkTest00176,cmdi,True,78,,,Command Injection
+BenchmarkTest00177,cmdi,False,78,,,Command Injection
+BenchmarkTest00178,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00179,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00180,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00181,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00182,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00183,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00184,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00185,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00186,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00187,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00188,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00189,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00190,sqli,False,89,,,SQL Injection
+BenchmarkTest00191,sqli,False,89,,,SQL Injection
+BenchmarkTest00192,sqli,True,89,,,SQL Injection
+BenchmarkTest00193,sqli,True,89,,,SQL Injection
+BenchmarkTest00194,sqli,True,89,,,SQL Injection
+BenchmarkTest00195,sqli,True,89,,,SQL Injection
+BenchmarkTest00196,sqli,True,89,,,SQL Injection
+BenchmarkTest00197,sqli,False,89,,,SQL Injection
+BenchmarkTest00198,sqli,True,89,,,SQL Injection
+BenchmarkTest00199,sqli,True,89,,,SQL Injection
+BenchmarkTest00200,sqli,False,89,,,SQL Injection
+BenchmarkTest00201,sqli,False,89,,,SQL Injection
+BenchmarkTest00202,sqli,False,89,,,SQL Injection
+BenchmarkTest00203,sqli,True,89,,,SQL Injection
+BenchmarkTest00204,sqli,True,89,,,SQL Injection
+BenchmarkTest00205,sqli,False,89,,,SQL Injection
+BenchmarkTest00206,sqli,False,89,,,SQL Injection
+BenchmarkTest00207,xpathi,True,643,,,XPATH Injection
+BenchmarkTest00208,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00209,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00210,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00211,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00212,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00213,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00214,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00215,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00216,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00217,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00218,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00219,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00220,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00221,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00222,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00223,hash,True,328,,,Weak Hashing
+BenchmarkTest00224,hash,False,328,,,Weak Hashing
+BenchmarkTest00225,hash,False,328,,,Weak Hashing
+BenchmarkTest00226,hash,True,328,,,Weak Hashing
+BenchmarkTest00227,hash,True,328,,,Weak Hashing
+BenchmarkTest00228,hash,False,328,,,Weak Hashing
+BenchmarkTest00229,hash,False,328,,,Weak Hashing
+BenchmarkTest00230,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00231,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00232,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00233,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00234,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00235,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00236,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00237,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00238,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00239,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00240,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00241,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00242,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest00243,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00244,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00245,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00246,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00247,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00248,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00249,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00250,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00251,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00252,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00253,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00254,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00255,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00256,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00257,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00258,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00259,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00260,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00261,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00262,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00263,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00264,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00265,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00266,hash,True,328,,,Weak Hashing
+BenchmarkTest00267,hash,True,328,,,Weak Hashing
+BenchmarkTest00268,hash,True,328,,,Weak Hashing
+BenchmarkTest00269,hash,True,328,,,Weak Hashing
+BenchmarkTest00270,hash,False,328,,,Weak Hashing
+BenchmarkTest00271,hash,False,328,,,Weak Hashing
+BenchmarkTest00272,hash,True,328,,,Weak Hashing
+BenchmarkTest00273,hash,True,328,,,Weak Hashing
+BenchmarkTest00274,hash,True,328,,,Weak Hashing
+BenchmarkTest00275,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00276,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00277,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00278,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00279,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00280,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00281,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00282,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00283,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00284,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00285,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00286,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00287,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00288,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00289,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00290,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00291,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00292,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00293,cmdi,True,78,,,Command Injection
+BenchmarkTest00294,cmdi,True,78,,,Command Injection
+BenchmarkTest00295,cmdi,True,78,,,Command Injection
+BenchmarkTest00296,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00297,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00298,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00299,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00300,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00301,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00302,cmdi,True,78,,,Command Injection
+BenchmarkTest00303,cmdi,True,78,,,Command Injection
+BenchmarkTest00304,cmdi,True,78,,,Command Injection
+BenchmarkTest00305,cmdi,False,78,,,Command Injection
+BenchmarkTest00306,cmdi,True,78,,,Command Injection
+BenchmarkTest00307,cmdi,False,78,,,Command Injection
+BenchmarkTest00308,cmdi,False,78,,,Command Injection
+BenchmarkTest00309,cmdi,False,78,,,Command Injection
+BenchmarkTest00310,cmdi,False,78,,,Command Injection
+BenchmarkTest00311,cmdi,True,78,,,Command Injection
+BenchmarkTest00312,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00313,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00314,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00315,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00316,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00317,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00318,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00319,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00320,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00321,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00322,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00323,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00324,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00325,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00326,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00327,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00328,sqli,True,89,,,SQL Injection
+BenchmarkTest00329,sqli,False,89,,,SQL Injection
+BenchmarkTest00330,sqli,False,89,,,SQL Injection
+BenchmarkTest00331,sqli,False,89,,,SQL Injection
+BenchmarkTest00332,sqli,False,89,,,SQL Injection
+BenchmarkTest00333,sqli,False,89,,,SQL Injection
+BenchmarkTest00334,sqli,False,89,,,SQL Injection
+BenchmarkTest00335,sqli,True,89,,,SQL Injection
+BenchmarkTest00336,sqli,False,89,,,SQL Injection
+BenchmarkTest00337,sqli,True,89,,,SQL Injection
+BenchmarkTest00338,sqli,False,89,,,SQL Injection
+BenchmarkTest00339,sqli,True,89,,,SQL Injection
+BenchmarkTest00340,sqli,False,89,,,SQL Injection
+BenchmarkTest00341,sqli,True,89,,,SQL Injection
+BenchmarkTest00342,sqli,True,89,,,SQL Injection
+BenchmarkTest00343,sqli,False,89,,,SQL Injection
+BenchmarkTest00344,sqli,False,89,,,SQL Injection
+BenchmarkTest00345,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00346,hash,True,328,,,Weak Hashing
+BenchmarkTest00347,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00348,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00349,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00350,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00351,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00352,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00353,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00354,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00355,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00356,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00357,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00358,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00359,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00360,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00361,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00362,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00363,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00364,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00365,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00366,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00367,ldapi,False,90,,,LDAP Injection
+BenchmarkTest00368,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00369,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00370,hash,False,328,,,Weak Hashing
+BenchmarkTest00371,hash,True,328,,,Weak Hashing
+BenchmarkTest00372,hash,True,328,,,Weak Hashing
+BenchmarkTest00373,hash,False,328,,,Weak Hashing
+BenchmarkTest00374,hash,True,328,,,Weak Hashing
+BenchmarkTest00375,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00376,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00377,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00378,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00379,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00380,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00381,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00382,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00383,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00384,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00385,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00386,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00387,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00388,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00389,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00390,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00391,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00392,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00393,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00394,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00395,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00396,cmdi,False,78,,,Command Injection
+BenchmarkTest00397,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00398,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00399,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00400,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00401,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00402,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00403,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00404,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest00405,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest00406,cmdi,False,78,,,Command Injection
+BenchmarkTest00407,cmdi,True,78,,,Command Injection
+BenchmarkTest00408,cmdi,False,78,,,Command Injection
+BenchmarkTest00409,cmdi,True,78,,,Command Injection
+BenchmarkTest00410,cmdi,False,78,,,Command Injection
+BenchmarkTest00411,cmdi,False,78,,,Command Injection
+BenchmarkTest00412,cmdi,False,78,,,Command Injection
+BenchmarkTest00413,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00414,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00415,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00416,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00417,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00418,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00419,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00420,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00421,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00422,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00423,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00424,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00425,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00426,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00427,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00428,sqli,True,89,,,SQL Injection
+BenchmarkTest00429,sqli,True,89,,,SQL Injection
+BenchmarkTest00430,sqli,False,89,,,SQL Injection
+BenchmarkTest00431,sqli,True,89,,,SQL Injection
+BenchmarkTest00432,sqli,False,89,,,SQL Injection
+BenchmarkTest00433,sqli,True,89,,,SQL Injection
+BenchmarkTest00434,sqli,True,89,,,SQL Injection
+BenchmarkTest00435,sqli,True,89,,,SQL Injection
+BenchmarkTest00436,sqli,False,89,,,SQL Injection
+BenchmarkTest00437,sqli,False,89,,,SQL Injection
+BenchmarkTest00438,sqli,True,89,,,SQL Injection
+BenchmarkTest00439,sqli,True,89,,,SQL Injection
+BenchmarkTest00440,sqli,False,89,,,SQL Injection
+BenchmarkTest00441,sqli,True,89,,,SQL Injection
+BenchmarkTest00442,xpathi,True,643,,,XPATH Injection
+BenchmarkTest00443,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00444,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00445,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00446,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00447,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00448,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00449,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00450,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00451,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00452,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00453,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00454,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00455,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00456,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00457,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00458,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00459,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00460,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00461,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00462,hash,True,328,,,Weak Hashing
+BenchmarkTest00463,hash,False,328,,,Weak Hashing
+BenchmarkTest00464,hash,True,328,,,Weak Hashing
+BenchmarkTest00465,hash,True,328,,,Weak Hashing
+BenchmarkTest00466,hash,False,328,,,Weak Hashing
+BenchmarkTest00467,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00468,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00469,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00470,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00471,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00472,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00473,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00474,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00475,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00476,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00477,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00478,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00479,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00480,cmdi,True,78,,,Command Injection
+BenchmarkTest00481,cmdi,False,78,,,Command Injection
+BenchmarkTest00482,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00483,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00484,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00485,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00486,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00487,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00488,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00489,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00490,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00491,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00492,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00493,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00494,cmdi,False,78,,,Command Injection
+BenchmarkTest00495,cmdi,True,78,,,Command Injection
+BenchmarkTest00496,cmdi,True,78,,,Command Injection
+BenchmarkTest00497,cmdi,True,78,,,Command Injection
+BenchmarkTest00498,cmdi,True,78,,,Command Injection
+BenchmarkTest00499,cmdi,True,78,,,Command Injection
+BenchmarkTest00500,cmdi,True,78,,,Command Injection
+BenchmarkTest00501,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00502,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00503,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00504,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00505,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00506,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00507,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00508,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00509,sqli,False,89,,,SQL Injection
+BenchmarkTest00510,sqli,True,89,,,SQL Injection
+BenchmarkTest00511,sqli,False,89,,,SQL Injection
+BenchmarkTest00512,sqli,True,89,,,SQL Injection
+BenchmarkTest00513,sqli,False,89,,,SQL Injection
+BenchmarkTest00514,sqli,False,89,,,SQL Injection
+BenchmarkTest00515,sqli,True,89,,,SQL Injection
+BenchmarkTest00516,sqli,True,89,,,SQL Injection
+BenchmarkTest00517,sqli,False,89,,,SQL Injection
+BenchmarkTest00518,sqli,True,89,,,SQL Injection
+BenchmarkTest00519,sqli,False,89,,,SQL Injection
+BenchmarkTest00520,xpathi,False,643,,,XPATH Injection
+BenchmarkTest00521,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00522,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00523,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00524,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00525,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00526,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00527,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00528,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00529,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00530,ldapi,False,90,,,LDAP Injection
+BenchmarkTest00531,hash,True,328,,,Weak Hashing
+BenchmarkTest00532,hash,True,328,,,Weak Hashing
+BenchmarkTest00533,hash,True,328,,,Weak Hashing
+BenchmarkTest00534,hash,True,328,,,Weak Hashing
+BenchmarkTest00535,hash,False,328,,,Weak Hashing
+BenchmarkTest00536,hash,True,328,,,Weak Hashing
+BenchmarkTest00537,hash,True,328,,,Weak Hashing
+BenchmarkTest00538,hash,False,328,,,Weak Hashing
+BenchmarkTest00539,hash,False,328,,,Weak Hashing
+BenchmarkTest00540,hash,False,328,,,Weak Hashing
+BenchmarkTest00541,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00542,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00543,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00544,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00545,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00546,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00547,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00548,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00549,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00550,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00551,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00552,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00553,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00554,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00555,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00556,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00557,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00558,cmdi,False,78,,,Command Injection
+BenchmarkTest00559,cmdi,False,78,,,Command Injection
+BenchmarkTest00560,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00561,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00562,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00563,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00564,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00565,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00566,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00567,cmdi,True,78,,,Command Injection
+BenchmarkTest00568,cmdi,True,78,,,Command Injection
+BenchmarkTest00569,cmdi,False,78,,,Command Injection
+BenchmarkTest00570,cmdi,False,78,,,Command Injection
+BenchmarkTest00571,cmdi,False,78,,,Command Injection
+BenchmarkTest00572,cmdi,False,78,,,Command Injection
+BenchmarkTest00573,cmdi,True,78,,,Command Injection
+BenchmarkTest00574,cmdi,True,78,,,Command Injection
+BenchmarkTest00575,cmdi,True,78,,,Command Injection
+BenchmarkTest00576,cmdi,True,78,,,Command Injection
+BenchmarkTest00577,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00578,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00579,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00580,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00581,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00582,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00583,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00584,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00585,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00586,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00587,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00588,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00589,sqli,False,89,,,SQL Injection
+BenchmarkTest00590,sqli,True,89,,,SQL Injection
+BenchmarkTest00591,sqli,True,89,,,SQL Injection
+BenchmarkTest00592,sqli,False,89,,,SQL Injection
+BenchmarkTest00593,sqli,True,89,,,SQL Injection
+BenchmarkTest00594,sqli,True,89,,,SQL Injection
+BenchmarkTest00595,sqli,True,89,,,SQL Injection
+BenchmarkTest00596,sqli,True,89,,,SQL Injection
+BenchmarkTest00597,sqli,True,89,,,SQL Injection
+BenchmarkTest00598,sqli,True,89,,,SQL Injection
+BenchmarkTest00599,sqli,False,89,,,SQL Injection
+BenchmarkTest00600,sqli,True,89,,,SQL Injection
+BenchmarkTest00601,sqli,False,89,,,SQL Injection
+BenchmarkTest00602,sqli,False,89,,,SQL Injection
+BenchmarkTest00603,sqli,True,89,,,SQL Injection
+BenchmarkTest00604,sqli,True,89,,,SQL Injection
+BenchmarkTest00605,sqli,False,89,,,SQL Injection
+BenchmarkTest00606,sqli,True,89,,,SQL Injection
+BenchmarkTest00607,xpathi,True,643,,,XPATH Injection
+BenchmarkTest00608,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00609,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00610,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00611,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00612,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00613,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00614,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00615,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00616,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00617,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00618,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00619,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00620,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00621,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00622,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00623,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00624,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00625,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00626,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00627,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00628,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00629,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00630,ldapi,True,90,,,LDAP Injection
+BenchmarkTest00631,hash,True,328,,,Weak Hashing
+BenchmarkTest00632,hash,False,328,,,Weak Hashing
+BenchmarkTest00633,hash,False,328,,,Weak Hashing
+BenchmarkTest00634,hash,True,328,,,Weak Hashing
+BenchmarkTest00635,hash,True,328,,,Weak Hashing
+BenchmarkTest00636,hash,True,328,,,Weak Hashing
+BenchmarkTest00637,hash,True,328,,,Weak Hashing
+BenchmarkTest00638,hash,True,328,,,Weak Hashing
+BenchmarkTest00639,hash,False,328,,,Weak Hashing
+BenchmarkTest00640,hash,False,328,,,Weak Hashing
+BenchmarkTest00641,hash,False,328,,,Weak Hashing
+BenchmarkTest00642,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00643,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00644,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00645,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00646,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00647,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00648,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00649,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00650,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00651,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00652,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00653,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00654,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00655,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest00656,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00657,cmdi,False,78,,,Command Injection
+BenchmarkTest00658,cmdi,False,78,,,Command Injection
+BenchmarkTest00659,cmdi,False,78,,,Command Injection
+BenchmarkTest00660,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00661,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00662,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00663,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00664,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00665,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00666,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00667,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00668,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00669,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00670,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00671,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00672,sqli,False,89,,,SQL Injection
+BenchmarkTest00673,sqli,True,89,,,SQL Injection
+BenchmarkTest00674,sqli,False,89,,,SQL Injection
+BenchmarkTest00675,sqli,False,89,,,SQL Injection
+BenchmarkTest00676,sqli,False,89,,,SQL Injection
+BenchmarkTest00677,sqli,True,89,,,SQL Injection
+BenchmarkTest00678,sqli,True,89,,,SQL Injection
+BenchmarkTest00679,sqli,True,89,,,SQL Injection
+BenchmarkTest00680,sqli,False,89,,,SQL Injection
+BenchmarkTest00681,sqli,True,89,,,SQL Injection
+BenchmarkTest00682,sqli,False,89,,,SQL Injection
+BenchmarkTest00683,xpathi,False,643,,,XPATH Injection
+BenchmarkTest00684,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00685,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00686,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00687,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00688,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00689,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00690,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00691,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00692,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00693,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00694,ldapi,True,90,,,LDAP Injection
+BenchmarkTest00695,ldapi,True,90,,,LDAP Injection
+BenchmarkTest00696,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00697,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00698,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00699,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00700,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00701,ldapi,False,90,,,LDAP Injection
+BenchmarkTest00702,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00703,hash,True,328,,,Weak Hashing
+BenchmarkTest00704,hash,True,328,,,Weak Hashing
+BenchmarkTest00705,hash,True,328,,,Weak Hashing
+BenchmarkTest00706,hash,False,328,,,Weak Hashing
+BenchmarkTest00707,hash,False,328,,,Weak Hashing
+BenchmarkTest00708,hash,True,328,,,Weak Hashing
+BenchmarkTest00709,hash,False,328,,,Weak Hashing
+BenchmarkTest00710,hash,True,328,,,Weak Hashing
+BenchmarkTest00711,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00712,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00713,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00714,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00715,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00716,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00717,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00718,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00719,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00720,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00721,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00722,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00723,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00724,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00725,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00726,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00727,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00728,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00729,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00730,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00731,cmdi,True,78,,,Command Injection
+BenchmarkTest00732,cmdi,False,78,,,Command Injection
+BenchmarkTest00733,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00734,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00735,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00736,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00737,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00738,cmdi,False,78,,,Command Injection
+BenchmarkTest00739,cmdi,False,78,,,Command Injection
+BenchmarkTest00740,cmdi,True,78,,,Command Injection
+BenchmarkTest00741,cmdi,False,78,,,Command Injection
+BenchmarkTest00742,cmdi,False,78,,,Command Injection
+BenchmarkTest00743,cmdi,False,78,,,Command Injection
+BenchmarkTest00744,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00745,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00746,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00747,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00748,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00749,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00750,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00751,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00752,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00753,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00754,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00755,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00756,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00757,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00758,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00759,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00760,sqli,True,89,,,SQL Injection
+BenchmarkTest00761,sqli,True,89,,,SQL Injection
+BenchmarkTest00762,sqli,True,89,,,SQL Injection
+BenchmarkTest00763,sqli,False,89,,,SQL Injection
+BenchmarkTest00764,sqli,True,89,,,SQL Injection
+BenchmarkTest00765,sqli,True,89,,,SQL Injection
+BenchmarkTest00766,sqli,False,89,,,SQL Injection
+BenchmarkTest00767,sqli,True,89,,,SQL Injection
+BenchmarkTest00768,sqli,True,89,,,SQL Injection
+BenchmarkTest00769,sqli,True,89,,,SQL Injection
+BenchmarkTest00770,sqli,True,89,,,SQL Injection
+BenchmarkTest00771,sqli,True,89,,,SQL Injection
+BenchmarkTest00772,sqli,False,89,,,SQL Injection
+BenchmarkTest00773,sqli,False,89,,,SQL Injection
+BenchmarkTest00774,sqli,False,89,,,SQL Injection
+BenchmarkTest00775,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00776,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00777,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00778,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00779,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00780,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00781,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00782,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00783,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00784,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00785,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00786,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00787,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00788,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00789,hash,True,328,,,Weak Hashing
+BenchmarkTest00790,hash,True,328,,,Weak Hashing
+BenchmarkTest00791,hash,False,328,,,Weak Hashing
+BenchmarkTest00792,hash,False,328,,,Weak Hashing
+BenchmarkTest00793,hash,False,328,,,Weak Hashing
+BenchmarkTest00794,hash,True,328,,,Weak Hashing
+BenchmarkTest00795,hash,False,328,,,Weak Hashing
+BenchmarkTest00796,hash,True,328,,,Weak Hashing
+BenchmarkTest00797,hash,True,328,,,Weak Hashing
+BenchmarkTest00798,hash,False,328,,,Weak Hashing
+BenchmarkTest00799,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00800,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00801,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00802,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00803,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00804,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00805,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00806,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00807,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00808,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00809,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00810,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00811,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00812,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00813,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00814,cmdi,False,78,,,Command Injection
+BenchmarkTest00815,cmdi,True,78,,,Command Injection
+BenchmarkTest00816,cmdi,True,78,,,Command Injection
+BenchmarkTest00817,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00818,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00819,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00820,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00821,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00822,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00823,cmdi,True,78,,,Command Injection
+BenchmarkTest00824,cmdi,True,78,,,Command Injection
+BenchmarkTest00825,cmdi,True,78,,,Command Injection
+BenchmarkTest00826,cmdi,False,78,,,Command Injection
+BenchmarkTest00827,cmdi,False,78,,,Command Injection
+BenchmarkTest00828,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00829,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00830,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00831,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00832,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00833,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00834,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00835,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00836,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00837,sqli,False,89,,,SQL Injection
+BenchmarkTest00838,sqli,False,89,,,SQL Injection
+BenchmarkTest00839,sqli,True,89,,,SQL Injection
+BenchmarkTest00840,sqli,True,89,,,SQL Injection
+BenchmarkTest00841,sqli,True,89,,,SQL Injection
+BenchmarkTest00842,sqli,True,89,,,SQL Injection
+BenchmarkTest00843,sqli,True,89,,,SQL Injection
+BenchmarkTest00844,sqli,False,89,,,SQL Injection
+BenchmarkTest00845,sqli,True,89,,,SQL Injection
+BenchmarkTest00846,sqli,True,89,,,SQL Injection
+BenchmarkTest00847,sqli,True,89,,,SQL Injection
+BenchmarkTest00848,sqli,True,89,,,SQL Injection
+BenchmarkTest00849,sqli,True,89,,,SQL Injection
+BenchmarkTest00850,sqli,True,89,,,SQL Injection
+BenchmarkTest00851,sqli,False,89,,,SQL Injection
+BenchmarkTest00852,xpathi,False,643,,,XPATH Injection
+BenchmarkTest00853,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00854,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00855,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00856,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00857,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00858,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00859,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00860,ldapi,False,90,,,LDAP Injection
+BenchmarkTest00861,ldapi,False,90,,,LDAP Injection
+BenchmarkTest00862,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00863,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00864,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00865,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00866,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00867,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00868,hash,True,328,,,Weak Hashing
+BenchmarkTest00869,hash,True,328,,,Weak Hashing
+BenchmarkTest00870,hash,True,328,,,Weak Hashing
+BenchmarkTest00871,hash,True,328,,,Weak Hashing
+BenchmarkTest00872,hash,True,328,,,Weak Hashing
+BenchmarkTest00873,hash,False,328,,,Weak Hashing
+BenchmarkTest00874,hash,False,328,,,Weak Hashing
+BenchmarkTest00875,hash,True,328,,,Weak Hashing
+BenchmarkTest00876,hash,True,328,,,Weak Hashing
+BenchmarkTest00877,hash,False,328,,,Weak Hashing
+BenchmarkTest00878,hash,False,328,,,Weak Hashing
+BenchmarkTest00879,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00880,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00881,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00882,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00883,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00884,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00885,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00886,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00887,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00888,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00889,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00890,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00891,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00892,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00893,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00894,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest00895,cmdi,False,78,,,Command Injection
+BenchmarkTest00896,cmdi,False,78,,,Command Injection
+BenchmarkTest00897,cmdi,False,78,,,Command Injection
+BenchmarkTest00898,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00899,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00900,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00901,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00902,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00903,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00904,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest00905,cmdi,False,78,,,Command Injection
+BenchmarkTest00906,cmdi,False,78,,,Command Injection
+BenchmarkTest00907,cmdi,False,78,,,Command Injection
+BenchmarkTest00908,cmdi,False,78,,,Command Injection
+BenchmarkTest00909,cmdi,False,78,,,Command Injection
+BenchmarkTest00910,cmdi,False,78,,,Command Injection
+BenchmarkTest00911,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00912,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00913,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00914,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00915,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00916,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00917,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00918,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00919,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00920,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00921,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00922,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00923,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00924,sqli,False,89,,,SQL Injection
+BenchmarkTest00925,sqli,False,89,,,SQL Injection
+BenchmarkTest00926,sqli,False,89,,,SQL Injection
+BenchmarkTest00927,sqli,False,89,,,SQL Injection
+BenchmarkTest00928,sqli,False,89,,,SQL Injection
+BenchmarkTest00929,sqli,False,89,,,SQL Injection
+BenchmarkTest00930,sqli,False,89,,,SQL Injection
+BenchmarkTest00931,sqli,False,89,,,SQL Injection
+BenchmarkTest00932,sqli,False,89,,,SQL Injection
+BenchmarkTest00933,sqli,False,89,,,SQL Injection
+BenchmarkTest00934,sqli,False,89,,,SQL Injection
+BenchmarkTest00935,sqli,False,89,,,SQL Injection
+BenchmarkTest00936,sqli,False,89,,,SQL Injection
+BenchmarkTest00937,sqli,False,89,,,SQL Injection
+BenchmarkTest00938,sqli,False,89,,,SQL Injection
+BenchmarkTest00939,sqli,False,89,,,SQL Injection
+BenchmarkTest00940,sqli,False,89,,,SQL Injection
+BenchmarkTest00941,xpathi,False,643,,,XPATH Injection
+BenchmarkTest00942,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00943,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00944,crypto,False,327,,,Weak Cryptography
+BenchmarkTest00945,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00946,crypto,True,327,,,Weak Cryptography
+BenchmarkTest00947,ldapi,True,90,,,LDAP Injection
+BenchmarkTest00948,ldapi,False,90,,,LDAP Injection
+BenchmarkTest00949,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00950,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00951,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00952,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00953,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00954,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00955,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00956,pathtraver,True,22,,,Path Traversal
+BenchmarkTest00957,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00958,pathtraver,False,22,,,Path Traversal
+BenchmarkTest00959,ldapi,True,90,,,LDAP Injection
+BenchmarkTest00960,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00961,hash,True,328,,,Weak Hashing
+BenchmarkTest00962,hash,False,328,,,Weak Hashing
+BenchmarkTest00963,hash,True,328,,,Weak Hashing
+BenchmarkTest00964,hash,False,328,,,Weak Hashing
+BenchmarkTest00965,hash,False,328,,,Weak Hashing
+BenchmarkTest00966,hash,False,328,,,Weak Hashing
+BenchmarkTest00967,hash,False,328,,,Weak Hashing
+BenchmarkTest00968,cmdi,True,78,,,Command Injection
+BenchmarkTest00969,cmdi,False,78,,,Command Injection
+BenchmarkTest00970,cmdi,False,78,,,Command Injection
+BenchmarkTest00971,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00972,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00973,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00974,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00975,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00976,weakrand,True,330,,,Weak Randomness
+BenchmarkTest00977,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest00978,cmdi,False,78,,,Command Injection
+BenchmarkTest00979,cmdi,True,78,,,Command Injection
+BenchmarkTest00980,cmdi,False,78,,,Command Injection
+BenchmarkTest00981,cmdi,True,78,,,Command Injection
+BenchmarkTest00982,cmdi,False,78,,,Command Injection
+BenchmarkTest00983,cmdi,True,78,,,Command Injection
+BenchmarkTest00984,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00985,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00986,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00987,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00988,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00989,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00990,weakrand,False,330,,,Weak Randomness
+BenchmarkTest00991,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00992,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00993,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest00994,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00995,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest00996,sqli,True,89,,,SQL Injection
+BenchmarkTest00997,sqli,True,89,,,SQL Injection
+BenchmarkTest00998,sqli,True,89,,,SQL Injection
+BenchmarkTest00999,sqli,False,89,,,SQL Injection
+BenchmarkTest01000,sqli,True,89,,,SQL Injection
+BenchmarkTest01001,sqli,False,89,,,SQL Injection
+BenchmarkTest01002,sqli,True,89,,,SQL Injection
+BenchmarkTest01003,sqli,True,89,,,SQL Injection
+BenchmarkTest01004,sqli,True,89,,,SQL Injection
+BenchmarkTest01005,sqli,True,89,,,SQL Injection
+BenchmarkTest01006,sqli,True,89,,,SQL Injection
+BenchmarkTest01007,sqli,True,89,,,SQL Injection
+BenchmarkTest01008,sqli,True,89,,,SQL Injection
+BenchmarkTest01009,sqli,True,89,,,SQL Injection
+BenchmarkTest01010,sqli,False,89,,,SQL Injection
+BenchmarkTest01011,sqli,True,89,,,SQL Injection
+BenchmarkTest01012,sqli,False,89,,,SQL Injection
+BenchmarkTest01013,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01014,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01015,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01016,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01017,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01018,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01019,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01020,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01021,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01022,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01023,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01024,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01025,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01026,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01027,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01028,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01029,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01030,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01031,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01032,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01033,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01034,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01035,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01036,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01037,hash,False,328,,,Weak Hashing
+BenchmarkTest01038,hash,True,328,,,Weak Hashing
+BenchmarkTest01039,hash,False,328,,,Weak Hashing
+BenchmarkTest01040,hash,False,328,,,Weak Hashing
+BenchmarkTest01041,hash,True,328,,,Weak Hashing
+BenchmarkTest01042,hash,True,328,,,Weak Hashing
+BenchmarkTest01043,hash,True,328,,,Weak Hashing
+BenchmarkTest01044,hash,True,328,,,Weak Hashing
+BenchmarkTest01045,hash,False,328,,,Weak Hashing
+BenchmarkTest01046,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01047,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01048,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01049,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01050,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01051,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01052,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01053,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01054,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01055,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01056,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01057,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01058,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01059,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01060,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01061,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01062,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01063,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01064,cmdi,True,78,,,Command Injection
+BenchmarkTest01065,cmdi,False,78,,,Command Injection
+BenchmarkTest01066,cmdi,True,78,,,Command Injection
+BenchmarkTest01067,cmdi,False,78,,,Command Injection
+BenchmarkTest01068,cmdi,False,78,,,Command Injection
+BenchmarkTest01069,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01070,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01071,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01072,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01073,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01074,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01075,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01076,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01077,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01078,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01079,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01080,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01081,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01082,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01083,sqli,True,89,,,SQL Injection
+BenchmarkTest01084,sqli,True,89,,,SQL Injection
+BenchmarkTest01085,sqli,False,89,,,SQL Injection
+BenchmarkTest01086,sqli,False,89,,,SQL Injection
+BenchmarkTest01087,sqli,True,89,,,SQL Injection
+BenchmarkTest01088,sqli,True,89,,,SQL Injection
+BenchmarkTest01089,sqli,False,89,,,SQL Injection
+BenchmarkTest01090,sqli,True,89,,,SQL Injection
+BenchmarkTest01091,sqli,True,89,,,SQL Injection
+BenchmarkTest01092,sqli,False,89,,,SQL Injection
+BenchmarkTest01093,sqli,True,89,,,SQL Injection
+BenchmarkTest01094,sqli,True,89,,,SQL Injection
+BenchmarkTest01095,sqli,False,89,,,SQL Injection
+BenchmarkTest01096,sqli,False,89,,,SQL Injection
+BenchmarkTest01097,sqli,True,89,,,SQL Injection
+BenchmarkTest01098,sqli,False,89,,,SQL Injection
+BenchmarkTest01099,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01100,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01101,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01102,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01103,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01104,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01105,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01106,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01107,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01108,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01109,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01110,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01111,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01112,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01113,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01114,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01115,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01116,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01117,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01118,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01119,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01120,hash,False,328,,,Weak Hashing
+BenchmarkTest01121,hash,False,328,,,Weak Hashing
+BenchmarkTest01122,hash,False,328,,,Weak Hashing
+BenchmarkTest01123,hash,True,328,,,Weak Hashing
+BenchmarkTest01124,hash,True,328,,,Weak Hashing
+BenchmarkTest01125,hash,False,328,,,Weak Hashing
+BenchmarkTest01126,hash,False,328,,,Weak Hashing
+BenchmarkTest01127,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01128,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01129,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01130,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01131,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01132,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01133,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01134,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01135,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01136,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01137,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01138,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01139,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01140,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01141,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01142,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01143,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01144,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01145,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01146,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01147,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01148,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01149,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01150,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01151,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01152,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01153,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01154,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01155,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01156,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01157,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01158,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01159,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01160,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01161,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01162,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01163,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01164,hash,False,328,,,Weak Hashing
+BenchmarkTest01165,hash,True,328,,,Weak Hashing
+BenchmarkTest01166,hash,True,328,,,Weak Hashing
+BenchmarkTest01167,hash,True,328,,,Weak Hashing
+BenchmarkTest01168,hash,True,328,,,Weak Hashing
+BenchmarkTest01169,hash,False,328,,,Weak Hashing
+BenchmarkTest01170,hash,False,328,,,Weak Hashing
+BenchmarkTest01171,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01172,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01173,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01174,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01175,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01176,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01177,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01178,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01179,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01180,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01181,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01182,cmdi,False,78,,,Command Injection
+BenchmarkTest01183,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01184,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01185,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01186,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01187,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01188,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01189,cmdi,False,78,,,Command Injection
+BenchmarkTest01190,cmdi,True,78,,,Command Injection
+BenchmarkTest01191,cmdi,True,78,,,Command Injection
+BenchmarkTest01192,cmdi,True,78,,,Command Injection
+BenchmarkTest01193,cmdi,False,78,,,Command Injection
+BenchmarkTest01194,cmdi,True,78,,,Command Injection
+BenchmarkTest01195,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01196,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01197,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01198,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01199,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01200,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01201,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01202,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01203,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01204,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01205,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01206,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01207,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01208,sqli,True,89,,,SQL Injection
+BenchmarkTest01209,sqli,True,89,,,SQL Injection
+BenchmarkTest01210,sqli,True,89,,,SQL Injection
+BenchmarkTest01211,sqli,True,89,,,SQL Injection
+BenchmarkTest01212,sqli,False,89,,,SQL Injection
+BenchmarkTest01213,sqli,False,89,,,SQL Injection
+BenchmarkTest01214,sqli,True,89,,,SQL Injection
+BenchmarkTest01215,sqli,False,89,,,SQL Injection
+BenchmarkTest01216,sqli,False,89,,,SQL Injection
+BenchmarkTest01217,sqli,False,89,,,SQL Injection
+BenchmarkTest01218,sqli,False,89,,,SQL Injection
+BenchmarkTest01219,sqli,False,89,,,SQL Injection
+BenchmarkTest01220,sqli,False,89,,,SQL Injection
+BenchmarkTest01221,sqli,True,89,,,SQL Injection
+BenchmarkTest01222,sqli,True,89,,,SQL Injection
+BenchmarkTest01223,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01224,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01225,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01226,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01227,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01228,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01229,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01230,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01231,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01232,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01233,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01234,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01235,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01236,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01237,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01238,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01239,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01240,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01241,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01242,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01243,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01244,hash,True,328,,,Weak Hashing
+BenchmarkTest01245,hash,False,328,,,Weak Hashing
+BenchmarkTest01246,hash,True,328,,,Weak Hashing
+BenchmarkTest01247,hash,True,328,,,Weak Hashing
+BenchmarkTest01248,hash,True,328,,,Weak Hashing
+BenchmarkTest01249,hash,False,328,,,Weak Hashing
+BenchmarkTest01250,hash,False,328,,,Weak Hashing
+BenchmarkTest01251,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01252,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01253,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01254,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01255,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01256,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01257,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01258,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01259,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01260,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01261,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01262,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01263,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01264,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01265,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01266,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01267,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01268,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01269,cmdi,False,78,,,Command Injection
+BenchmarkTest01270,cmdi,True,78,,,Command Injection
+BenchmarkTest01271,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01272,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01273,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01274,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01275,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01276,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01277,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01278,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01279,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01280,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01281,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01282,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01283,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01284,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01285,cmdi,True,78,,,Command Injection
+BenchmarkTest01286,cmdi,True,78,,,Command Injection
+BenchmarkTest01287,cmdi,True,78,,,Command Injection
+BenchmarkTest01288,cmdi,True,78,,,Command Injection
+BenchmarkTest01289,cmdi,False,78,,,Command Injection
+BenchmarkTest01290,cmdi,False,78,,,Command Injection
+BenchmarkTest01291,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01292,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01293,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01294,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01295,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01296,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01297,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01298,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01299,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01300,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01301,sqli,False,89,,,SQL Injection
+BenchmarkTest01302,sqli,True,89,,,SQL Injection
+BenchmarkTest01303,sqli,False,89,,,SQL Injection
+BenchmarkTest01304,sqli,True,89,,,SQL Injection
+BenchmarkTest01305,sqli,False,89,,,SQL Injection
+BenchmarkTest01306,sqli,True,89,,,SQL Injection
+BenchmarkTest01307,sqli,False,89,,,SQL Injection
+BenchmarkTest01308,sqli,True,89,,,SQL Injection
+BenchmarkTest01309,sqli,False,89,,,SQL Injection
+BenchmarkTest01310,sqli,False,89,,,SQL Injection
+BenchmarkTest01311,sqli,True,89,,,SQL Injection
+BenchmarkTest01312,sqli,True,89,,,SQL Injection
+BenchmarkTest01313,sqli,True,89,,,SQL Injection
+BenchmarkTest01314,sqli,True,89,,,SQL Injection
+BenchmarkTest01315,sqli,False,89,,,SQL Injection
+BenchmarkTest01316,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01317,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01318,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01319,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01320,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01321,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01322,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01323,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01324,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01325,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01326,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01327,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01328,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01329,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01330,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01331,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01332,hash,False,328,,,Weak Hashing
+BenchmarkTest01333,hash,True,328,,,Weak Hashing
+BenchmarkTest01334,hash,True,328,,,Weak Hashing
+BenchmarkTest01335,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01336,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01337,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01338,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01339,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01340,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01341,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01342,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01343,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01344,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01345,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01346,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01347,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01348,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01349,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01350,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01351,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01352,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01353,cmdi,False,78,,,Command Injection
+BenchmarkTest01354,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01355,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01356,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01357,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01358,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01359,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01360,cmdi,True,78,,,Command Injection
+BenchmarkTest01361,cmdi,True,78,,,Command Injection
+BenchmarkTest01362,cmdi,True,78,,,Command Injection
+BenchmarkTest01363,cmdi,True,78,,,Command Injection
+BenchmarkTest01364,cmdi,False,78,,,Command Injection
+BenchmarkTest01365,cmdi,False,78,,,Command Injection
+BenchmarkTest01366,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01367,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01368,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01369,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01370,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01371,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01372,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01373,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01374,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01375,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01376,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01377,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01378,sqli,False,89,,,SQL Injection
+BenchmarkTest01379,sqli,True,89,,,SQL Injection
+BenchmarkTest01380,sqli,False,89,,,SQL Injection
+BenchmarkTest01381,sqli,True,89,,,SQL Injection
+BenchmarkTest01382,sqli,True,89,,,SQL Injection
+BenchmarkTest01383,sqli,True,89,,,SQL Injection
+BenchmarkTest01384,sqli,True,89,,,SQL Injection
+BenchmarkTest01385,sqli,False,89,,,SQL Injection
+BenchmarkTest01386,sqli,False,89,,,SQL Injection
+BenchmarkTest01387,sqli,False,89,,,SQL Injection
+BenchmarkTest01388,sqli,True,89,,,SQL Injection
+BenchmarkTest01389,sqli,False,89,,,SQL Injection
+BenchmarkTest01390,sqli,True,89,,,SQL Injection
+BenchmarkTest01391,sqli,True,89,,,SQL Injection
+BenchmarkTest01392,sqli,False,89,,,SQL Injection
+BenchmarkTest01393,sqli,False,89,,,SQL Injection
+BenchmarkTest01394,sqli,True,89,,,SQL Injection
+BenchmarkTest01395,sqli,True,89,,,SQL Injection
+BenchmarkTest01396,sqli,True,89,,,SQL Injection
+BenchmarkTest01397,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01398,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01399,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01400,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01401,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01402,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01403,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01404,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01405,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01406,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01407,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01408,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01409,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01410,hash,False,328,,,Weak Hashing
+BenchmarkTest01411,hash,True,328,,,Weak Hashing
+BenchmarkTest01412,hash,False,328,,,Weak Hashing
+BenchmarkTest01413,hash,False,328,,,Weak Hashing
+BenchmarkTest01414,hash,True,328,,,Weak Hashing
+BenchmarkTest01415,hash,True,328,,,Weak Hashing
+BenchmarkTest01416,hash,True,328,,,Weak Hashing
+BenchmarkTest01417,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01418,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01419,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01420,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01421,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01422,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01423,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01424,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01425,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01426,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01427,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01428,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01429,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01430,cmdi,True,78,,,Command Injection
+BenchmarkTest01431,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01432,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01433,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01434,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01435,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01436,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01437,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01438,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01439,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01440,cmdi,False,78,,,Command Injection
+BenchmarkTest01441,cmdi,True,78,,,Command Injection
+BenchmarkTest01442,cmdi,True,78,,,Command Injection
+BenchmarkTest01443,cmdi,False,78,,,Command Injection
+BenchmarkTest01444,cmdi,False,78,,,Command Injection
+BenchmarkTest01445,cmdi,False,78,,,Command Injection
+BenchmarkTest01446,cmdi,True,78,,,Command Injection
+BenchmarkTest01447,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01448,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01449,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01450,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01451,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01452,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01453,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01454,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01455,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01456,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01457,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01458,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01459,sqli,False,89,,,SQL Injection
+BenchmarkTest01460,sqli,True,89,,,SQL Injection
+BenchmarkTest01461,sqli,False,89,,,SQL Injection
+BenchmarkTest01462,sqli,True,89,,,SQL Injection
+BenchmarkTest01463,sqli,True,89,,,SQL Injection
+BenchmarkTest01464,sqli,True,89,,,SQL Injection
+BenchmarkTest01465,sqli,True,89,,,SQL Injection
+BenchmarkTest01466,sqli,True,89,,,SQL Injection
+BenchmarkTest01467,sqli,False,89,,,SQL Injection
+BenchmarkTest01468,sqli,False,89,,,SQL Injection
+BenchmarkTest01469,sqli,False,89,,,SQL Injection
+BenchmarkTest01470,sqli,True,89,,,SQL Injection
+BenchmarkTest01471,sqli,True,89,,,SQL Injection
+BenchmarkTest01472,sqli,False,89,,,SQL Injection
+BenchmarkTest01473,sqli,True,89,,,SQL Injection
+BenchmarkTest01474,sqli,True,89,,,SQL Injection
+BenchmarkTest01475,sqli,True,89,,,SQL Injection
+BenchmarkTest01476,sqli,True,89,,,SQL Injection
+BenchmarkTest01477,sqli,True,89,,,SQL Injection
+BenchmarkTest01478,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01479,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01480,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01481,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01482,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01483,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01484,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01485,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01486,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01487,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01488,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01489,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01490,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01491,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01492,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01493,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01494,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01495,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01496,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01497,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01498,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01499,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01500,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01501,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01502,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01503,hash,True,328,,,Weak Hashing
+BenchmarkTest01504,hash,True,328,,,Weak Hashing
+BenchmarkTest01505,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01506,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01507,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01508,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01509,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01510,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01511,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01512,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01513,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01514,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01515,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01516,cmdi,False,78,,,Command Injection
+BenchmarkTest01517,cmdi,True,78,,,Command Injection
+BenchmarkTest01518,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01519,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01520,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01521,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01522,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01523,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01524,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01525,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01526,cmdi,False,78,,,Command Injection
+BenchmarkTest01527,cmdi,False,78,,,Command Injection
+BenchmarkTest01528,cmdi,False,78,,,Command Injection
+BenchmarkTest01529,cmdi,False,78,,,Command Injection
+BenchmarkTest01530,cmdi,False,78,,,Command Injection
+BenchmarkTest01531,cmdi,True,78,,,Command Injection
+BenchmarkTest01532,cmdi,False,78,,,Command Injection
+BenchmarkTest01533,cmdi,True,78,,,Command Injection
+BenchmarkTest01534,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01535,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01536,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01537,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01538,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01539,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01540,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01541,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01542,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01543,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01544,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01545,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01546,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01547,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01548,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01549,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01550,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01551,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01552,sqli,True,89,,,SQL Injection
+BenchmarkTest01553,sqli,False,89,,,SQL Injection
+BenchmarkTest01554,sqli,True,89,,,SQL Injection
+BenchmarkTest01555,sqli,False,89,,,SQL Injection
+BenchmarkTest01556,sqli,False,89,,,SQL Injection
+BenchmarkTest01557,sqli,True,89,,,SQL Injection
+BenchmarkTest01558,sqli,True,89,,,SQL Injection
+BenchmarkTest01559,sqli,True,89,,,SQL Injection
+BenchmarkTest01560,sqli,True,89,,,SQL Injection
+BenchmarkTest01561,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01562,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01563,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01564,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01565,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01566,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01567,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01568,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01569,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01570,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01571,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01572,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01573,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01574,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01575,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01576,hash,False,328,,,Weak Hashing
+BenchmarkTest01577,hash,True,328,,,Weak Hashing
+BenchmarkTest01578,hash,False,328,,,Weak Hashing
+BenchmarkTest01579,hash,True,328,,,Weak Hashing
+BenchmarkTest01580,hash,True,328,,,Weak Hashing
+BenchmarkTest01581,hash,False,328,,,Weak Hashing
+BenchmarkTest01582,hash,False,328,,,Weak Hashing
+BenchmarkTest01583,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01584,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01585,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01586,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01587,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01588,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01589,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01590,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01591,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01592,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01593,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01594,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01595,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01596,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01597,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01598,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01599,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01600,cmdi,False,78,,,Command Injection
+BenchmarkTest01601,cmdi,True,78,,,Command Injection
+BenchmarkTest01602,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01603,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01604,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01605,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01606,cmdi,False,78,,,Command Injection
+BenchmarkTest01607,cmdi,False,78,,,Command Injection
+BenchmarkTest01608,cmdi,False,78,,,Command Injection
+BenchmarkTest01609,cmdi,True,78,,,Command Injection
+BenchmarkTest01610,cmdi,True,78,,,Command Injection
+BenchmarkTest01611,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01612,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01613,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01614,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01615,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01616,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01617,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01618,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01619,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01620,sqli,True,89,,,SQL Injection
+BenchmarkTest01621,sqli,True,89,,,SQL Injection
+BenchmarkTest01622,sqli,False,89,,,SQL Injection
+BenchmarkTest01623,sqli,True,89,,,SQL Injection
+BenchmarkTest01624,sqli,True,89,,,SQL Injection
+BenchmarkTest01625,sqli,True,89,,,SQL Injection
+BenchmarkTest01626,sqli,True,89,,,SQL Injection
+BenchmarkTest01627,sqli,True,89,,,SQL Injection
+BenchmarkTest01628,sqli,False,89,,,SQL Injection
+BenchmarkTest01629,sqli,False,89,,,SQL Injection
+BenchmarkTest01630,sqli,True,89,,,SQL Injection
+BenchmarkTest01631,sqli,True,89,,,SQL Injection
+BenchmarkTest01632,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01633,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01634,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01635,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01636,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01637,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01638,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01639,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01640,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01641,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01642,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01643,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01644,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01645,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01646,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01647,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01648,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01649,hash,True,328,,,Weak Hashing
+BenchmarkTest01650,hash,True,328,,,Weak Hashing
+BenchmarkTest01651,hash,True,328,,,Weak Hashing
+BenchmarkTest01652,hash,False,328,,,Weak Hashing
+BenchmarkTest01653,hash,True,328,,,Weak Hashing
+BenchmarkTest01654,hash,True,328,,,Weak Hashing
+BenchmarkTest01655,hash,False,328,,,Weak Hashing
+BenchmarkTest01656,hash,False,328,,,Weak Hashing
+BenchmarkTest01657,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01658,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01659,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01660,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01661,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01662,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01663,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01664,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01665,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01666,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01667,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01668,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01669,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01670,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01671,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01672,cmdi,False,78,,,Command Injection
+BenchmarkTest01673,cmdi,True,78,,,Command Injection
+BenchmarkTest01674,cmdi,True,78,,,Command Injection
+BenchmarkTest01675,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01676,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01677,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01678,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01679,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01680,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01681,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01682,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01683,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01684,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01685,cmdi,True,78,,,Command Injection
+BenchmarkTest01686,cmdi,False,78,,,Command Injection
+BenchmarkTest01687,cmdi,False,78,,,Command Injection
+BenchmarkTest01688,cmdi,False,78,,,Command Injection
+BenchmarkTest01689,cmdi,True,78,,,Command Injection
+BenchmarkTest01690,cmdi,True,78,,,Command Injection
+BenchmarkTest01691,cmdi,True,78,,,Command Injection
+BenchmarkTest01692,cmdi,False,78,,,Command Injection
+BenchmarkTest01693,cmdi,False,78,,,Command Injection
+BenchmarkTest01694,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01695,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01696,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01697,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01698,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01699,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01700,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01701,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01702,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01703,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01704,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01705,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01706,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01707,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01708,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01709,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01710,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01711,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01712,sqli,True,89,,,SQL Injection
+BenchmarkTest01713,sqli,False,89,,,SQL Injection
+BenchmarkTest01714,sqli,False,89,,,SQL Injection
+BenchmarkTest01715,sqli,True,89,,,SQL Injection
+BenchmarkTest01716,sqli,True,89,,,SQL Injection
+BenchmarkTest01717,sqli,False,89,,,SQL Injection
+BenchmarkTest01718,sqli,True,89,,,SQL Injection
+BenchmarkTest01719,sqli,False,89,,,SQL Injection
+BenchmarkTest01720,sqli,True,89,,,SQL Injection
+BenchmarkTest01721,sqli,True,89,,,SQL Injection
+BenchmarkTest01722,sqli,False,89,,,SQL Injection
+BenchmarkTest01723,sqli,True,89,,,SQL Injection
+BenchmarkTest01724,sqli,True,89,,,SQL Injection
+BenchmarkTest01725,sqli,True,89,,,SQL Injection
+BenchmarkTest01726,sqli,True,89,,,SQL Injection
+BenchmarkTest01727,sqli,True,89,,,SQL Injection
+BenchmarkTest01728,sqli,True,89,,,SQL Injection
+BenchmarkTest01729,sqli,False,89,,,SQL Injection
+BenchmarkTest01730,sqli,True,89,,,SQL Injection
+BenchmarkTest01731,sqli,True,89,,,SQL Injection
+BenchmarkTest01732,sqli,False,89,,,SQL Injection
+BenchmarkTest01733,sqli,True,89,,,SQL Injection
+BenchmarkTest01734,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01735,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01736,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01737,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01738,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01739,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01740,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01741,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01742,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01743,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01744,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01745,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01746,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01747,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01748,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01749,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01750,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01751,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01752,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01753,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01754,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01755,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01756,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01757,hash,True,328,,,Weak Hashing
+BenchmarkTest01758,hash,False,328,,,Weak Hashing
+BenchmarkTest01759,hash,False,328,,,Weak Hashing
+BenchmarkTest01760,hash,False,328,,,Weak Hashing
+BenchmarkTest01761,hash,True,328,,,Weak Hashing
+BenchmarkTest01762,hash,False,328,,,Weak Hashing
+BenchmarkTest01763,hash,False,328,,,Weak Hashing
+BenchmarkTest01764,hash,False,328,,,Weak Hashing
+BenchmarkTest01765,hash,True,328,,,Weak Hashing
+BenchmarkTest01766,hash,True,328,,,Weak Hashing
+BenchmarkTest01767,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01768,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01769,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01770,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01771,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01772,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01773,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01774,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01775,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01776,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01777,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01778,cmdi,False,78,,,Command Injection
+BenchmarkTest01779,cmdi,False,78,,,Command Injection
+BenchmarkTest01780,cmdi,False,78,,,Command Injection
+BenchmarkTest01781,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01782,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01783,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01784,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01785,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01786,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01787,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01788,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01789,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01790,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01791,cmdi,False,78,,,Command Injection
+BenchmarkTest01792,cmdi,False,78,,,Command Injection
+BenchmarkTest01793,cmdi,False,78,,,Command Injection
+BenchmarkTest01794,cmdi,False,78,,,Command Injection
+BenchmarkTest01795,cmdi,False,78,,,Command Injection
+BenchmarkTest01796,cmdi,False,78,,,Command Injection
+BenchmarkTest01797,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01798,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01799,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01800,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01801,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01802,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01803,sqli,False,89,,,SQL Injection
+BenchmarkTest01804,sqli,False,89,,,SQL Injection
+BenchmarkTest01805,sqli,False,89,,,SQL Injection
+BenchmarkTest01806,sqli,False,89,,,SQL Injection
+BenchmarkTest01807,sqli,False,89,,,SQL Injection
+BenchmarkTest01808,sqli,False,89,,,SQL Injection
+BenchmarkTest01809,sqli,False,89,,,SQL Injection
+BenchmarkTest01810,sqli,False,89,,,SQL Injection
+BenchmarkTest01811,sqli,False,89,,,SQL Injection
+BenchmarkTest01812,sqli,False,89,,,SQL Injection
+BenchmarkTest01813,sqli,False,89,,,SQL Injection
+BenchmarkTest01814,sqli,False,89,,,SQL Injection
+BenchmarkTest01815,sqli,False,89,,,SQL Injection
+BenchmarkTest01816,sqli,False,89,,,SQL Injection
+BenchmarkTest01817,sqli,False,89,,,SQL Injection
+BenchmarkTest01818,sqli,False,89,,,SQL Injection
+BenchmarkTest01819,sqli,False,89,,,SQL Injection
+BenchmarkTest01820,sqli,False,89,,,SQL Injection
+BenchmarkTest01821,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01822,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01823,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01824,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01825,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01826,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01827,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01828,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01829,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01830,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01831,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01832,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01833,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01834,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01835,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01836,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01837,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01838,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01839,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01840,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01841,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01842,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01843,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01844,hash,True,328,,,Weak Hashing
+BenchmarkTest01845,hash,True,328,,,Weak Hashing
+BenchmarkTest01846,hash,True,328,,,Weak Hashing
+BenchmarkTest01847,hash,False,328,,,Weak Hashing
+BenchmarkTest01848,hash,False,328,,,Weak Hashing
+BenchmarkTest01849,hash,False,328,,,Weak Hashing
+BenchmarkTest01850,cmdi,True,78,,,Command Injection
+BenchmarkTest01851,cmdi,True,78,,,Command Injection
+BenchmarkTest01852,cmdi,True,78,,,Command Injection
+BenchmarkTest01853,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01854,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01855,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01856,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01857,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01858,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01859,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01860,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01861,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest01862,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01863,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01864,cmdi,True,78,,,Command Injection
+BenchmarkTest01865,cmdi,False,78,,,Command Injection
+BenchmarkTest01866,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01867,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01868,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01869,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01870,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01871,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01872,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01873,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01874,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01875,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01876,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01877,sqli,False,89,,,SQL Injection
+BenchmarkTest01878,sqli,False,89,,,SQL Injection
+BenchmarkTest01879,sqli,False,89,,,SQL Injection
+BenchmarkTest01880,sqli,False,89,,,SQL Injection
+BenchmarkTest01881,sqli,True,89,,,SQL Injection
+BenchmarkTest01882,sqli,True,89,,,SQL Injection
+BenchmarkTest01883,sqli,True,89,,,SQL Injection
+BenchmarkTest01884,sqli,False,89,,,SQL Injection
+BenchmarkTest01885,sqli,False,89,,,SQL Injection
+BenchmarkTest01886,sqli,False,89,,,SQL Injection
+BenchmarkTest01887,sqli,True,89,,,SQL Injection
+BenchmarkTest01888,sqli,True,89,,,SQL Injection
+BenchmarkTest01889,sqli,True,89,,,SQL Injection
+BenchmarkTest01890,sqli,True,89,,,SQL Injection
+BenchmarkTest01891,sqli,True,89,,,SQL Injection
+BenchmarkTest01892,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01893,xpathi,False,643,,,XPATH Injection
+BenchmarkTest01894,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01895,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01896,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01897,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01898,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01899,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01900,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01901,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01902,ldapi,True,90,,,LDAP Injection
+BenchmarkTest01903,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01904,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01905,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01906,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01907,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01908,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01909,ldapi,False,90,,,LDAP Injection
+BenchmarkTest01910,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01911,hash,True,328,,,Weak Hashing
+BenchmarkTest01912,hash,False,328,,,Weak Hashing
+BenchmarkTest01913,hash,False,328,,,Weak Hashing
+BenchmarkTest01914,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01915,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01916,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01917,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01918,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01919,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01920,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01921,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01922,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01923,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01924,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01925,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01926,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01927,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest01928,cmdi,True,78,,,Command Injection
+BenchmarkTest01929,cmdi,True,78,,,Command Injection
+BenchmarkTest01930,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01931,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01932,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01933,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01934,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01935,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest01936,cmdi,True,78,,,Command Injection
+BenchmarkTest01937,cmdi,False,78,,,Command Injection
+BenchmarkTest01938,cmdi,True,78,,,Command Injection
+BenchmarkTest01939,cmdi,False,78,,,Command Injection
+BenchmarkTest01940,cmdi,True,78,,,Command Injection
+BenchmarkTest01941,cmdi,False,78,,,Command Injection
+BenchmarkTest01942,cmdi,True,78,,,Command Injection
+BenchmarkTest01943,cmdi,False,78,,,Command Injection
+BenchmarkTest01944,cmdi,True,78,,,Command Injection
+BenchmarkTest01945,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01946,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01947,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01948,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01949,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01950,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01951,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01952,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01953,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01954,weakrand,False,330,,,Weak Randomness
+BenchmarkTest01955,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01956,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01957,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01958,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01959,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest01960,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest01961,sqli,False,89,,,SQL Injection
+BenchmarkTest01962,sqli,True,89,,,SQL Injection
+BenchmarkTest01963,sqli,True,89,,,SQL Injection
+BenchmarkTest01964,sqli,True,89,,,SQL Injection
+BenchmarkTest01965,sqli,False,89,,,SQL Injection
+BenchmarkTest01966,sqli,False,89,,,SQL Injection
+BenchmarkTest01967,sqli,False,89,,,SQL Injection
+BenchmarkTest01968,sqli,False,89,,,SQL Injection
+BenchmarkTest01969,sqli,False,89,,,SQL Injection
+BenchmarkTest01970,sqli,True,89,,,SQL Injection
+BenchmarkTest01971,sqli,True,89,,,SQL Injection
+BenchmarkTest01972,sqli,True,89,,,SQL Injection
+BenchmarkTest01973,sqli,False,89,,,SQL Injection
+BenchmarkTest01974,xpathi,True,643,,,XPATH Injection
+BenchmarkTest01975,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01976,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01977,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01978,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01979,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01980,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01981,crypto,True,327,,,Weak Cryptography
+BenchmarkTest01982,crypto,False,327,,,Weak Cryptography
+BenchmarkTest01983,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01984,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01985,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01986,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01987,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01988,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01989,pathtraver,True,22,,,Path Traversal
+BenchmarkTest01990,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01991,pathtraver,False,22,,,Path Traversal
+BenchmarkTest01992,weakrand,True,330,,,Weak Randomness
+BenchmarkTest01993,hash,False,328,,,Weak Hashing
+BenchmarkTest01994,hash,False,328,,,Weak Hashing
+BenchmarkTest01995,hash,False,328,,,Weak Hashing
+BenchmarkTest01996,hash,True,328,,,Weak Hashing
+BenchmarkTest01997,hash,True,328,,,Weak Hashing
+BenchmarkTest01998,hash,False,328,,,Weak Hashing
+BenchmarkTest01999,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02000,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02001,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02002,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02003,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02004,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02005,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest02006,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02007,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02008,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02009,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02010,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02011,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02012,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02013,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02014,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02015,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02016,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02017,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02018,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02019,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02020,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02021,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02022,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02023,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02024,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02025,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02026,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02027,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02028,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02029,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02030,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02031,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02032,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02033,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02034,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02035,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02036,ldapi,True,90,,,LDAP Injection
+BenchmarkTest02037,ldapi,True,90,,,LDAP Injection
+BenchmarkTest02038,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02039,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02040,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02041,hash,False,328,,,Weak Hashing
+BenchmarkTest02042,hash,True,328,,,Weak Hashing
+BenchmarkTest02043,hash,False,328,,,Weak Hashing
+BenchmarkTest02044,hash,False,328,,,Weak Hashing
+BenchmarkTest02045,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02046,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02047,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02048,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02049,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02050,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02051,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02052,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02053,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02054,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02055,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02056,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02057,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02058,cmdi,False,78,,,Command Injection
+BenchmarkTest02059,cmdi,True,78,,,Command Injection
+BenchmarkTest02060,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02061,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02062,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02063,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02064,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02065,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02066,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02067,cmdi,False,78,,,Command Injection
+BenchmarkTest02068,cmdi,False,78,,,Command Injection
+BenchmarkTest02069,cmdi,False,78,,,Command Injection
+BenchmarkTest02070,cmdi,True,78,,,Command Injection
+BenchmarkTest02071,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02072,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02073,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02074,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02075,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02076,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02077,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02078,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02079,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02080,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02081,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02082,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02083,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02084,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02085,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02086,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02087,sqli,True,89,,,SQL Injection
+BenchmarkTest02088,sqli,True,89,,,SQL Injection
+BenchmarkTest02089,sqli,False,89,,,SQL Injection
+BenchmarkTest02090,sqli,True,89,,,SQL Injection
+BenchmarkTest02091,sqli,True,89,,,SQL Injection
+BenchmarkTest02092,sqli,True,89,,,SQL Injection
+BenchmarkTest02093,sqli,False,89,,,SQL Injection
+BenchmarkTest02094,sqli,True,89,,,SQL Injection
+BenchmarkTest02095,sqli,False,89,,,SQL Injection
+BenchmarkTest02096,sqli,True,89,,,SQL Injection
+BenchmarkTest02097,sqli,False,89,,,SQL Injection
+BenchmarkTest02098,sqli,False,89,,,SQL Injection
+BenchmarkTest02099,sqli,True,89,,,SQL Injection
+BenchmarkTest02100,xpathi,True,643,,,XPATH Injection
+BenchmarkTest02101,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02102,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02103,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02104,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02105,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02106,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02107,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02108,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02109,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02110,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02111,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02112,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02113,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02114,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02115,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02116,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02117,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02118,hash,True,328,,,Weak Hashing
+BenchmarkTest02119,hash,False,328,,,Weak Hashing
+BenchmarkTest02120,hash,False,328,,,Weak Hashing
+BenchmarkTest02121,hash,True,328,,,Weak Hashing
+BenchmarkTest02122,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02123,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02124,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02125,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02126,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02127,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02128,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02129,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02130,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02131,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02132,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02133,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02134,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02135,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02136,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02137,cmdi,True,78,,,Command Injection
+BenchmarkTest02138,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02139,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02140,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02141,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02142,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest02143,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02144,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02145,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02146,cmdi,True,78,,,Command Injection
+BenchmarkTest02147,cmdi,True,78,,,Command Injection
+BenchmarkTest02148,cmdi,False,78,,,Command Injection
+BenchmarkTest02149,cmdi,False,78,,,Command Injection
+BenchmarkTest02150,cmdi,True,78,,,Command Injection
+BenchmarkTest02151,cmdi,True,78,,,Command Injection
+BenchmarkTest02152,cmdi,True,78,,,Command Injection
+BenchmarkTest02153,cmdi,False,78,,,Command Injection
+BenchmarkTest02154,cmdi,True,78,,,Command Injection
+BenchmarkTest02155,cmdi,True,78,,,Command Injection
+BenchmarkTest02156,cmdi,False,78,,,Command Injection
+BenchmarkTest02157,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02158,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02159,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02160,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02161,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02162,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02163,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02164,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02165,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02166,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02167,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02168,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02169,sqli,True,89,,,SQL Injection
+BenchmarkTest02170,sqli,True,89,,,SQL Injection
+BenchmarkTest02171,sqli,True,89,,,SQL Injection
+BenchmarkTest02172,sqli,False,89,,,SQL Injection
+BenchmarkTest02173,sqli,False,89,,,SQL Injection
+BenchmarkTest02174,sqli,False,89,,,SQL Injection
+BenchmarkTest02175,sqli,False,89,,,SQL Injection
+BenchmarkTest02176,sqli,False,89,,,SQL Injection
+BenchmarkTest02177,sqli,True,89,,,SQL Injection
+BenchmarkTest02178,sqli,True,89,,,SQL Injection
+BenchmarkTest02179,sqli,True,89,,,SQL Injection
+BenchmarkTest02180,sqli,False,89,,,SQL Injection
+BenchmarkTest02181,sqli,True,89,,,SQL Injection
+BenchmarkTest02182,sqli,True,89,,,SQL Injection
+BenchmarkTest02183,sqli,False,89,,,SQL Injection
+BenchmarkTest02184,sqli,False,89,,,SQL Injection
+BenchmarkTest02185,sqli,False,89,,,SQL Injection
+BenchmarkTest02186,sqli,True,89,,,SQL Injection
+BenchmarkTest02187,sqli,True,89,,,SQL Injection
+BenchmarkTest02188,sqli,False,89,,,SQL Injection
+BenchmarkTest02189,xpathi,True,643,,,XPATH Injection
+BenchmarkTest02190,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02191,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02192,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02193,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02194,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02195,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02196,ldapi,True,90,,,LDAP Injection
+BenchmarkTest02197,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02198,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02199,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02200,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02201,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02202,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02203,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02204,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02205,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02206,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02207,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02208,ldapi,True,90,,,LDAP Injection
+BenchmarkTest02209,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02210,hash,False,328,,,Weak Hashing
+BenchmarkTest02211,hash,True,328,,,Weak Hashing
+BenchmarkTest02212,hash,True,328,,,Weak Hashing
+BenchmarkTest02213,hash,True,328,,,Weak Hashing
+BenchmarkTest02214,hash,False,328,,,Weak Hashing
+BenchmarkTest02215,hash,False,328,,,Weak Hashing
+BenchmarkTest02216,hash,False,328,,,Weak Hashing
+BenchmarkTest02217,hash,True,328,,,Weak Hashing
+BenchmarkTest02218,hash,False,328,,,Weak Hashing
+BenchmarkTest02219,hash,True,328,,,Weak Hashing
+BenchmarkTest02220,hash,False,328,,,Weak Hashing
+BenchmarkTest02221,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02222,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02223,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02224,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02225,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02226,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02227,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02228,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02229,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02230,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02231,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02232,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02233,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02234,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02235,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02236,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02237,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02238,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02239,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02240,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02241,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02242,cmdi,False,78,,,Command Injection
+BenchmarkTest02243,cmdi,True,78,,,Command Injection
+BenchmarkTest02244,cmdi,True,78,,,Command Injection
+BenchmarkTest02245,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02246,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02247,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02248,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02249,cmdi,True,78,,,Command Injection
+BenchmarkTest02250,cmdi,True,78,,,Command Injection
+BenchmarkTest02251,cmdi,True,78,,,Command Injection
+BenchmarkTest02252,cmdi,False,78,,,Command Injection
+BenchmarkTest02253,cmdi,False,78,,,Command Injection
+BenchmarkTest02254,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02255,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02256,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02257,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02258,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02259,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02260,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02261,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02262,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02263,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02264,sqli,True,89,,,SQL Injection
+BenchmarkTest02265,sqli,False,89,,,SQL Injection
+BenchmarkTest02266,sqli,False,89,,,SQL Injection
+BenchmarkTest02267,sqli,False,89,,,SQL Injection
+BenchmarkTest02268,sqli,False,89,,,SQL Injection
+BenchmarkTest02269,sqli,True,89,,,SQL Injection
+BenchmarkTest02270,sqli,True,89,,,SQL Injection
+BenchmarkTest02271,sqli,False,89,,,SQL Injection
+BenchmarkTest02272,sqli,True,89,,,SQL Injection
+BenchmarkTest02273,sqli,True,89,,,SQL Injection
+BenchmarkTest02274,sqli,False,89,,,SQL Injection
+BenchmarkTest02275,sqli,True,89,,,SQL Injection
+BenchmarkTest02276,sqli,False,89,,,SQL Injection
+BenchmarkTest02277,sqli,True,89,,,SQL Injection
+BenchmarkTest02278,sqli,False,89,,,SQL Injection
+BenchmarkTest02279,sqli,False,89,,,SQL Injection
+BenchmarkTest02280,sqli,False,89,,,SQL Injection
+BenchmarkTest02281,sqli,True,89,,,SQL Injection
+BenchmarkTest02282,sqli,False,89,,,SQL Injection
+BenchmarkTest02283,sqli,False,89,,,SQL Injection
+BenchmarkTest02284,sqli,True,89,,,SQL Injection
+BenchmarkTest02285,sqli,False,89,,,SQL Injection
+BenchmarkTest02286,sqli,True,89,,,SQL Injection
+BenchmarkTest02287,sqli,True,89,,,SQL Injection
+BenchmarkTest02288,sqli,True,89,,,SQL Injection
+BenchmarkTest02289,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02290,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02291,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02292,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02293,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02294,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02295,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02296,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02297,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02298,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02299,ldapi,True,90,,,LDAP Injection
+BenchmarkTest02300,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02301,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02302,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02303,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02304,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02305,ldapi,True,90,,,LDAP Injection
+BenchmarkTest02306,ldapi,True,90,,,LDAP Injection
+BenchmarkTest02307,hash,True,328,,,Weak Hashing
+BenchmarkTest02308,hash,True,328,,,Weak Hashing
+BenchmarkTest02309,hash,False,328,,,Weak Hashing
+BenchmarkTest02310,hash,False,328,,,Weak Hashing
+BenchmarkTest02311,hash,True,328,,,Weak Hashing
+BenchmarkTest02312,hash,False,328,,,Weak Hashing
+BenchmarkTest02313,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02314,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02315,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02316,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02317,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02318,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02319,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02320,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02321,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02322,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02323,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02324,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02325,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02326,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02327,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02328,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02329,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02330,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02331,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02332,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02333,cmdi,True,78,,,Command Injection
+BenchmarkTest02334,cmdi,True,78,,,Command Injection
+BenchmarkTest02335,cmdi,False,78,,,Command Injection
+BenchmarkTest02336,cmdi,False,78,,,Command Injection
+BenchmarkTest02337,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02338,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02339,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest02340,cmdi,False,78,,,Command Injection
+BenchmarkTest02341,cmdi,False,78,,,Command Injection
+BenchmarkTest02342,cmdi,True,78,,,Command Injection
+BenchmarkTest02343,cmdi,True,78,,,Command Injection
+BenchmarkTest02344,cmdi,True,78,,,Command Injection
+BenchmarkTest02345,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02346,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02347,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02348,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02349,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02350,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02351,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02352,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02353,sqli,False,89,,,SQL Injection
+BenchmarkTest02354,sqli,True,89,,,SQL Injection
+BenchmarkTest02355,sqli,True,89,,,SQL Injection
+BenchmarkTest02356,sqli,True,89,,,SQL Injection
+BenchmarkTest02357,sqli,True,89,,,SQL Injection
+BenchmarkTest02358,sqli,True,89,,,SQL Injection
+BenchmarkTest02359,sqli,True,89,,,SQL Injection
+BenchmarkTest02360,sqli,True,89,,,SQL Injection
+BenchmarkTest02361,sqli,False,89,,,SQL Injection
+BenchmarkTest02362,sqli,True,89,,,SQL Injection
+BenchmarkTest02363,sqli,False,89,,,SQL Injection
+BenchmarkTest02364,sqli,True,89,,,SQL Injection
+BenchmarkTest02365,sqli,False,89,,,SQL Injection
+BenchmarkTest02366,sqli,False,89,,,SQL Injection
+BenchmarkTest02367,sqli,False,89,,,SQL Injection
+BenchmarkTest02368,sqli,False,89,,,SQL Injection
+BenchmarkTest02369,sqli,True,89,,,SQL Injection
+BenchmarkTest02370,xpathi,False,643,,,XPATH Injection
+BenchmarkTest02371,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02372,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02373,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02374,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02375,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02376,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02377,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02378,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02379,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02380,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02381,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02382,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02383,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02384,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02385,hash,True,328,,,Weak Hashing
+BenchmarkTest02386,hash,True,328,,,Weak Hashing
+BenchmarkTest02387,hash,True,328,,,Weak Hashing
+BenchmarkTest02388,hash,True,328,,,Weak Hashing
+BenchmarkTest02389,hash,False,328,,,Weak Hashing
+BenchmarkTest02390,hash,False,328,,,Weak Hashing
+BenchmarkTest02391,hash,True,328,,,Weak Hashing
+BenchmarkTest02392,hash,True,328,,,Weak Hashing
+BenchmarkTest02393,hash,True,328,,,Weak Hashing
+BenchmarkTest02394,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02395,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02396,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02397,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02398,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02399,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02400,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02401,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02402,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02403,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02404,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02405,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02406,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02407,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02408,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02409,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02410,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02411,cmdi,True,78,,,Command Injection
+BenchmarkTest02412,cmdi,True,78,,,Command Injection
+BenchmarkTest02413,cmdi,False,78,,,Command Injection
+BenchmarkTest02414,cmdi,True,78,,,Command Injection
+BenchmarkTest02415,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02416,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02417,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02418,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02419,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02420,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02421,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02422,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02423,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02424,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02425,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02426,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02427,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest02428,cmdi,False,78,,,Command Injection
+BenchmarkTest02429,cmdi,True,78,,,Command Injection
+BenchmarkTest02430,cmdi,True,78,,,Command Injection
+BenchmarkTest02431,cmdi,True,78,,,Command Injection
+BenchmarkTest02432,cmdi,True,78,,,Command Injection
+BenchmarkTest02433,cmdi,True,78,,,Command Injection
+BenchmarkTest02434,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02435,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02436,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02437,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02438,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02439,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02440,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02441,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02442,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02443,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02444,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02445,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02446,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02447,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02448,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02449,sqli,True,89,,,SQL Injection
+BenchmarkTest02450,sqli,False,89,,,SQL Injection
+BenchmarkTest02451,sqli,True,89,,,SQL Injection
+BenchmarkTest02452,sqli,False,89,,,SQL Injection
+BenchmarkTest02453,sqli,True,89,,,SQL Injection
+BenchmarkTest02454,sqli,True,89,,,SQL Injection
+BenchmarkTest02455,sqli,True,89,,,SQL Injection
+BenchmarkTest02456,sqli,False,89,,,SQL Injection
+BenchmarkTest02457,xpathi,False,643,,,XPATH Injection
+BenchmarkTest02458,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02459,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02460,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02461,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02462,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02463,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02464,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02465,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02466,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02467,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02468,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02469,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02470,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02471,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02472,ldapi,True,90,,,LDAP Injection
+BenchmarkTest02473,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02474,hash,True,328,,,Weak Hashing
+BenchmarkTest02475,hash,True,328,,,Weak Hashing
+BenchmarkTest02476,hash,True,328,,,Weak Hashing
+BenchmarkTest02477,hash,False,328,,,Weak Hashing
+BenchmarkTest02478,hash,True,328,,,Weak Hashing
+BenchmarkTest02479,hash,False,328,,,Weak Hashing
+BenchmarkTest02480,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02481,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02482,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02483,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02484,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02485,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02486,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02487,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02488,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02489,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02490,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02491,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02492,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02493,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02494,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02495,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02496,cmdi,True,78,,,Command Injection
+BenchmarkTest02497,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02498,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02499,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02500,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02501,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02502,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02503,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02504,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02505,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02506,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02507,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest02508,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02509,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02510,cmdi,False,78,,,Command Injection
+BenchmarkTest02511,cmdi,True,78,,,Command Injection
+BenchmarkTest02512,cmdi,True,78,,,Command Injection
+BenchmarkTest02513,cmdi,False,78,,,Command Injection
+BenchmarkTest02514,cmdi,True,78,,,Command Injection
+BenchmarkTest02515,cmdi,True,78,,,Command Injection
+BenchmarkTest02516,cmdi,True,78,,,Command Injection
+BenchmarkTest02517,cmdi,True,78,,,Command Injection
+BenchmarkTest02518,cmdi,False,78,,,Command Injection
+BenchmarkTest02519,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02520,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02521,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02522,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02523,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02524,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02525,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02526,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02527,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02528,sqli,True,89,,,SQL Injection
+BenchmarkTest02529,sqli,False,89,,,SQL Injection
+BenchmarkTest02530,sqli,True,89,,,SQL Injection
+BenchmarkTest02531,sqli,True,89,,,SQL Injection
+BenchmarkTest02532,sqli,True,89,,,SQL Injection
+BenchmarkTest02533,sqli,True,89,,,SQL Injection
+BenchmarkTest02534,sqli,True,89,,,SQL Injection
+BenchmarkTest02535,sqli,True,89,,,SQL Injection
+BenchmarkTest02536,sqli,False,89,,,SQL Injection
+BenchmarkTest02537,sqli,True,89,,,SQL Injection
+BenchmarkTest02538,sqli,False,89,,,SQL Injection
+BenchmarkTest02539,sqli,False,89,,,SQL Injection
+BenchmarkTest02540,sqli,False,89,,,SQL Injection
+BenchmarkTest02541,sqli,False,89,,,SQL Injection
+BenchmarkTest02542,sqli,True,89,,,SQL Injection
+BenchmarkTest02543,sqli,True,89,,,SQL Injection
+BenchmarkTest02544,sqli,False,89,,,SQL Injection
+BenchmarkTest02545,sqli,True,89,,,SQL Injection
+BenchmarkTest02546,sqli,False,89,,,SQL Injection
+BenchmarkTest02547,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02548,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02549,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02550,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02551,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02552,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02553,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02554,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02555,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02556,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02557,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02558,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02559,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02560,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02561,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02562,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02563,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02564,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02565,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02566,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02567,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02568,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02569,pathtraver,True,22,,,Path Traversal
+BenchmarkTest02570,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02571,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02572,ldapi,False,90,,,LDAP Injection
+BenchmarkTest02573,hash,True,328,,,Weak Hashing
+BenchmarkTest02574,hash,True,328,,,Weak Hashing
+BenchmarkTest02575,hash,True,328,,,Weak Hashing
+BenchmarkTest02576,hash,False,328,,,Weak Hashing
+BenchmarkTest02577,hash,True,328,,,Weak Hashing
+BenchmarkTest02578,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02579,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02580,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02581,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02582,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02583,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02584,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02585,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02586,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02587,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02588,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02589,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02590,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02591,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02592,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02593,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02594,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02595,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02596,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02597,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02598,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02599,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02600,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02601,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02602,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02603,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02604,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02605,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02606,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02607,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02608,xss,True,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02609,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02610,cmdi,False,78,,,Command Injection
+BenchmarkTest02611,cmdi,True,78,,,Command Injection
+BenchmarkTest02612,cmdi,True,78,,,Command Injection
+BenchmarkTest02613,cmdi,True,78,,,Command Injection
+BenchmarkTest02614,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02615,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02616,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02617,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02618,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02619,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02620,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02621,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02622,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02623,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02624,trustbound,True,501,,,Trust Boundary Violation
+BenchmarkTest02625,sqli,True,89,,,SQL Injection
+BenchmarkTest02626,sqli,False,89,,,SQL Injection
+BenchmarkTest02627,sqli,True,89,,,SQL Injection
+BenchmarkTest02628,sqli,True,89,,,SQL Injection
+BenchmarkTest02629,sqli,False,89,,,SQL Injection
+BenchmarkTest02630,sqli,True,89,,,SQL Injection
+BenchmarkTest02631,sqli,False,89,,,SQL Injection
+BenchmarkTest02632,sqli,True,89,,,SQL Injection
+BenchmarkTest02633,sqli,False,89,,,SQL Injection
+BenchmarkTest02634,sqli,False,89,,,SQL Injection
+BenchmarkTest02635,sqli,True,89,,,SQL Injection
+BenchmarkTest02636,sqli,False,89,,,SQL Injection
+BenchmarkTest02637,sqli,False,89,,,SQL Injection
+BenchmarkTest02638,sqli,True,89,,,SQL Injection
+BenchmarkTest02639,sqli,False,89,,,SQL Injection
+BenchmarkTest02640,sqli,False,89,,,SQL Injection
+BenchmarkTest02641,sqli,True,89,,,SQL Injection
+BenchmarkTest02642,sqli,True,89,,,SQL Injection
+BenchmarkTest02643,sqli,True,89,,,SQL Injection
+BenchmarkTest02644,sqli,True,89,,,SQL Injection
+BenchmarkTest02645,sqli,True,89,,,SQL Injection
+BenchmarkTest02646,sqli,True,89,,,SQL Injection
+BenchmarkTest02647,sqli,True,89,,,SQL Injection
+BenchmarkTest02648,sqli,False,89,,,SQL Injection
+BenchmarkTest02649,sqli,True,89,,,SQL Injection
+BenchmarkTest02650,sqli,True,89,,,SQL Injection
+BenchmarkTest02651,sqli,True,89,,,SQL Injection
+BenchmarkTest02652,sqli,False,89,,,SQL Injection
+BenchmarkTest02653,sqli,True,89,,,SQL Injection
+BenchmarkTest02654,sqli,True,89,,,SQL Injection
+BenchmarkTest02655,sqli,True,89,,,SQL Injection
+BenchmarkTest02656,sqli,True,89,,,SQL Injection
+BenchmarkTest02657,sqli,False,89,,,SQL Injection
+BenchmarkTest02658,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02659,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02660,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02661,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02662,crypto,False,327,,,Weak Cryptography
+BenchmarkTest02663,crypto,True,327,,,Weak Cryptography
+BenchmarkTest02664,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02665,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02666,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02667,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02668,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02669,pathtraver,False,22,,,Path Traversal
+BenchmarkTest02670,hash,True,328,,,Weak Hashing
+BenchmarkTest02671,hash,True,328,,,Weak Hashing
+BenchmarkTest02672,hash,False,328,,,Weak Hashing
+BenchmarkTest02673,hash,False,328,,,Weak Hashing
+BenchmarkTest02674,hash,True,328,,,Weak Hashing
+BenchmarkTest02675,hash,True,328,,,Weak Hashing
+BenchmarkTest02676,hash,False,328,,,Weak Hashing
+BenchmarkTest02677,hash,True,328,,,Weak Hashing
+BenchmarkTest02678,hash,False,328,,,Weak Hashing
+BenchmarkTest02679,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02680,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02681,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02682,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02683,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02684,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02685,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02686,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02687,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02688,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02689,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02690,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02691,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02692,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02693,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02694,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02695,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02696,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02697,cmdi,False,78,,,Command Injection
+BenchmarkTest02698,cmdi,False,78,,,Command Injection
+BenchmarkTest02699,cmdi,False,78,,,Command Injection
+BenchmarkTest02700,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02701,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02702,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02703,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02704,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02705,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02706,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02707,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02708,weakrand,True,330,,,Weak Randomness
+BenchmarkTest02709,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest02710,securecookie,True,614,,,Secure Cookie Flag
+BenchmarkTest02711,securecookie,False,614,,,Secure Cookie Flag
+BenchmarkTest02712,xss,False,79,,,XSS (Cross-Site Scripting)
+BenchmarkTest02713,cmdi,False,78,,,Command Injection
+BenchmarkTest02714,cmdi,False,78,,,Command Injection
+BenchmarkTest02715,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02716,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02717,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02718,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02719,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02720,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02721,weakrand,False,330,,,Weak Randomness
+BenchmarkTest02722,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02723,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02724,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02725,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02726,trustbound,False,501,,,Trust Boundary Violation
+BenchmarkTest02727,sqli,False,89,,,SQL Injection
+BenchmarkTest02728,sqli,False,89,,,SQL Injection
+BenchmarkTest02729,sqli,False,89,,,SQL Injection
+BenchmarkTest02730,sqli,False,89,,,SQL Injection
+BenchmarkTest02731,sqli,False,89,,,SQL Injection
+BenchmarkTest02732,sqli,False,89,,,SQL Injection
+BenchmarkTest02733,sqli,False,89,,,SQL Injection
+BenchmarkTest02734,sqli,False,89,,,SQL Injection
+BenchmarkTest02735,sqli,False,89,,,SQL Injection
+BenchmarkTest02736,sqli,False,89,,,SQL Injection
+BenchmarkTest02737,sqli,False,89,,,SQL Injection
+BenchmarkTest02738,sqli,False,89,,,SQL Injection
+BenchmarkTest02739,sqli,False,89,,,SQL Injection
+BenchmarkTest02740,sqli,False,89,,,SQL Injection
diff --git a/OWASP DATASET CLEANED/mappings/cwe_to_category_mapping.txt b/OWASP DATASET CLEANED/mappings/cwe_to_category_mapping.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65a2be173abf049c53113c47d837a293c43f053c
--- /dev/null
+++ b/OWASP DATASET CLEANED/mappings/cwe_to_category_mapping.txt	
@@ -0,0 +1,30 @@
+CWE to Category Mapping
+=======================
+
+CWE-22: pathtraver
+CWE-78: cmdi
+CWE-79: xss
+CWE-89: sqli
+CWE-90: ldapi
+CWE-327: crypto
+CWE-328: hash
+CWE-330: weakrand
+CWE-501: trustbound
+CWE-614: securecookie
+CWE-643: xpathi
+
+
+CWE Sample Counts
+=================
+
+CWE-22: 268 samples
+CWE-78: 251 samples
+CWE-79: 455 samples
+CWE-89: 504 samples
+CWE-90: 59 samples
+CWE-327: 246 samples
+CWE-328: 236 samples
+CWE-330: 493 samples
+CWE-501: 126 samples
+CWE-614: 67 samples
+CWE-643: 35 samples